2014-09-29 13:40:13 +00:00
|
|
|
require 'spec_helper'
|
|
|
|
|
2015-12-09 09:50:51 +00:00
|
|
|
describe Repository, models: true do
|
2014-09-29 13:40:13 +00:00
|
|
|
include RepoHelpers
|
2016-03-25 12:18:55 +00:00
|
|
|
TestBlob = Struct.new(:name)
|
2014-09-29 13:40:13 +00:00
|
|
|
|
2016-07-18 08:16:56 +00:00
|
|
|
let(:project) { create(:project) }
|
|
|
|
let(:repository) { project.repository }
|
2015-11-26 00:20:40 +00:00
|
|
|
let(:user) { create(:user) }
|
2016-10-04 14:03:13 +00:00
|
|
|
|
2016-02-02 01:24:52 +00:00
|
|
|
let(:commit_options) do
|
|
|
|
author = repository.user_to_committer(user)
|
|
|
|
{ message: 'Test message', committer: author, author: author }
|
|
|
|
end
|
2016-10-04 14:03:13 +00:00
|
|
|
|
2016-02-10 23:02:46 +00:00
|
|
|
let(:merge_commit) do
|
2016-07-18 08:16:56 +00:00
|
|
|
merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
|
|
|
|
merge_commit_id = repository.merge(user, merge_request, commit_options)
|
|
|
|
repository.commit(merge_commit_id)
|
2016-02-02 01:24:52 +00:00
|
|
|
end
|
2016-10-04 14:03:13 +00:00
|
|
|
|
2016-09-08 15:40:07 +00:00
|
|
|
let(:author_email) { FFaker::Internet.email }
|
|
|
|
|
|
|
|
# I have to remove periods from the end of the name
|
|
|
|
# This happened when the user's name had a suffix (i.e. "Sr.")
|
|
|
|
# This seems to be what git does under the hood. For example, this commit:
|
|
|
|
#
|
|
|
|
# $ git commit --author='Foo Sr. <foo@example.com>' -m 'Where's my trailing period?'
|
|
|
|
#
|
|
|
|
# results in this:
|
|
|
|
#
|
|
|
|
# $ git show --pretty
|
|
|
|
# ...
|
|
|
|
# Author: Foo Sr <foo@example.com>
|
|
|
|
# ...
|
|
|
|
let(:author_name) { FFaker::Name.name.chomp("\.") }
|
2014-09-29 13:40:13 +00:00
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#branch_names_contains' do
|
2014-09-29 13:40:13 +00:00
|
|
|
subject { repository.branch_names_contains(sample_commit.id) }
|
|
|
|
|
2015-02-12 18:17:35 +00:00
|
|
|
it { is_expected.to include('master') }
|
|
|
|
it { is_expected.not_to include('feature') }
|
|
|
|
it { is_expected.not_to include('fix') }
|
2014-09-29 13:40:13 +00:00
|
|
|
end
|
2014-09-29 13:45:16 +00:00
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#tag_names_contains' do
|
2015-03-22 18:01:45 +00:00
|
|
|
subject { repository.tag_names_contains(sample_commit.id) }
|
2015-03-09 22:10:59 +00:00
|
|
|
|
2015-03-22 18:01:45 +00:00
|
|
|
it { is_expected.to include('v1.1.0') }
|
|
|
|
it { is_expected.not_to include('v1.0.0') }
|
2015-03-13 10:39:26 +00:00
|
|
|
end
|
|
|
|
|
2016-06-16 17:33:29 +00:00
|
|
|
describe 'tags_sorted_by' do
|
|
|
|
context 'name' do
|
|
|
|
subject { repository.tags_sorted_by('name').map(&:name) }
|
|
|
|
|
|
|
|
it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'updated' do
|
|
|
|
let(:tag_a) { repository.find_tag('v1.0.0') }
|
|
|
|
let(:tag_b) { repository.find_tag('v1.1.0') }
|
|
|
|
|
|
|
|
context 'desc' do
|
|
|
|
subject { repository.tags_sorted_by('updated_desc').map(&:name) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
double_first = double(committed_date: Time.now)
|
|
|
|
double_last = double(committed_date: Time.now - 1.second)
|
|
|
|
|
2016-07-27 15:26:29 +00:00
|
|
|
allow(tag_a).to receive(:target).and_return(double_first)
|
|
|
|
allow(tag_b).to receive(:target).and_return(double_last)
|
|
|
|
allow(repository).to receive(:tags).and_return([tag_a, tag_b])
|
2016-06-16 17:33:29 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq(['v1.0.0', 'v1.1.0']) }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'asc' do
|
|
|
|
subject { repository.tags_sorted_by('updated_asc').map(&:name) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
double_first = double(committed_date: Time.now - 1.second)
|
|
|
|
double_last = double(committed_date: Time.now)
|
|
|
|
|
2016-07-27 15:26:29 +00:00
|
|
|
allow(tag_a).to receive(:target).and_return(double_last)
|
|
|
|
allow(tag_b).to receive(:target).and_return(double_first)
|
|
|
|
allow(repository).to receive(:tags).and_return([tag_a, tag_b])
|
2016-06-16 17:33:29 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-10-04 14:03:13 +00:00
|
|
|
describe '#ref_name_for_sha' do
|
|
|
|
context 'ref found' do
|
|
|
|
it 'returns the ref' do
|
|
|
|
allow_any_instance_of(Gitlab::Popen).to receive(:popen).
|
|
|
|
and_return(["b8d95eb4969eefacb0a58f6a28f6803f8070e7b9 commit\trefs/environments/production/77\n", 0])
|
|
|
|
|
|
|
|
expect(repository.ref_name_for_sha('bla', '0' * 40)).to eq 'refs/environments/production/77'
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'ref not found' do
|
|
|
|
it 'returns nil' do
|
|
|
|
allow_any_instance_of(Gitlab::Popen).to receive(:popen).
|
|
|
|
and_return(["", 0])
|
|
|
|
|
|
|
|
expect(repository.ref_name_for_sha('bla', '0' * 40)).to eq nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#last_commit_for_path' do
|
2015-03-22 18:01:45 +00:00
|
|
|
subject { repository.last_commit_for_path(sample_commit.id, '.gitignore').id }
|
2015-03-13 10:39:26 +00:00
|
|
|
|
2015-03-22 18:01:45 +00:00
|
|
|
it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
|
2015-03-09 22:10:59 +00:00
|
|
|
end
|
2015-07-01 09:02:37 +00:00
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#find_commits_by_message' do
|
2016-10-10 08:11:46 +00:00
|
|
|
it 'returns commits with messages containing a given string' do
|
|
|
|
commit_ids = repository.find_commits_by_message('submodule').map(&:id)
|
2015-06-14 22:04:20 +00:00
|
|
|
|
2016-10-10 08:11:46 +00:00
|
|
|
expect(commit_ids).to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
|
|
|
|
expect(commit_ids).to include('6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9')
|
|
|
|
expect(commit_ids).to include('cfe32cf61b73a0d5e9f13e774abde7ff789b1660')
|
|
|
|
expect(commit_ids).not_to include('913c66a37b4a45b9769037c55c2d238bd0942d2e')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is case insensitive' do
|
|
|
|
commit_ids = repository.find_commits_by_message('SUBMODULE').map(&:id)
|
|
|
|
|
|
|
|
expect(commit_ids).to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
|
|
|
|
end
|
2015-06-14 22:04:20 +00:00
|
|
|
end
|
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#blob_at' do
|
2015-07-01 09:02:37 +00:00
|
|
|
context 'blank sha' do
|
|
|
|
subject { repository.blob_at(Gitlab::Git::BLANK_SHA, '.gitignore') }
|
|
|
|
|
|
|
|
it { is_expected.to be_nil }
|
|
|
|
end
|
|
|
|
end
|
2015-07-01 15:24:03 +00:00
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#merged_to_root_ref?' do
|
2016-10-03 12:11:16 +00:00
|
|
|
context 'merged branch without ff' do
|
2016-09-27 15:39:29 +00:00
|
|
|
subject { repository.merged_to_root_ref?('branch-merged') }
|
2015-08-09 18:31:50 +00:00
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
2016-09-27 15:39:29 +00:00
|
|
|
|
2016-10-03 12:11:16 +00:00
|
|
|
# If the HEAD was ff then it will be false
|
|
|
|
context 'merged with ff' do
|
2015-08-09 18:31:50 +00:00
|
|
|
subject { repository.merged_to_root_ref?('improve/awesome') }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
2016-10-03 12:11:16 +00:00
|
|
|
|
2016-09-27 15:39:29 +00:00
|
|
|
context 'not merged branch' do
|
|
|
|
subject { repository.merged_to_root_ref?('not-merged-branch') }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
2016-10-03 12:11:16 +00:00
|
|
|
|
|
|
|
context 'default branch' do
|
|
|
|
subject { repository.merged_to_root_ref?('master') }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
2015-08-17 09:41:53 +00:00
|
|
|
end
|
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#can_be_merged?' do
|
2015-08-11 12:33:31 +00:00
|
|
|
context 'mergeable branches' do
|
|
|
|
subject { repository.can_be_merged?('0b4bc9a49b562e85de7cc9e834518ea6828729b9', 'master') }
|
|
|
|
|
|
|
|
it { is_expected.to be_truthy }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'non-mergeable branches' do
|
|
|
|
subject { repository.can_be_merged?('bb5206fee213d983da88c47f9cf4cc6caf9c66dc', 'feature') }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
2015-08-09 18:31:50 +00:00
|
|
|
|
|
|
|
context 'non merged branch' do
|
|
|
|
subject { repository.merged_to_root_ref?('fix') }
|
|
|
|
|
|
|
|
it { is_expected.to be_falsey }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'non existent branch' do
|
|
|
|
subject { repository.merged_to_root_ref?('non_existent_branch') }
|
|
|
|
|
|
|
|
it { is_expected.to be_nil }
|
|
|
|
end
|
2015-08-11 12:33:31 +00:00
|
|
|
end
|
|
|
|
|
2016-09-08 15:40:07 +00:00
|
|
|
describe "#commit_dir" do
|
|
|
|
it "commits a change that creates a new directory" do
|
|
|
|
expect do
|
|
|
|
repository.commit_dir(user, 'newdir', 'Create newdir', 'master')
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
newdir = repository.tree('master', 'newdir')
|
|
|
|
expect(newdir.path).to eq('newdir')
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when an author is specified" do
|
|
|
|
it "uses the given email/name to set the commit's author" do
|
|
|
|
expect do
|
|
|
|
repository.commit_dir(user, "newdir", "Add newdir", 'master', author_email: author_email, author_name: author_name)
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
last_commit = repository.commit
|
|
|
|
|
|
|
|
expect(last_commit.author_email).to eq(author_email)
|
|
|
|
expect(last_commit.author_name).to eq(author_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "#commit_file" do
|
2016-07-18 22:13:21 +00:00
|
|
|
it 'commits change to a file successfully' do
|
|
|
|
expect do
|
2016-07-19 11:03:27 +00:00
|
|
|
repository.commit_file(user, 'CHANGELOG', 'Changelog!',
|
|
|
|
'Updates file content',
|
2016-07-18 22:13:21 +00:00
|
|
|
'master', true)
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
2016-07-19 11:03:27 +00:00
|
|
|
blob = repository.blob_at('master', 'CHANGELOG')
|
2016-07-18 22:13:21 +00:00
|
|
|
|
2016-07-19 11:03:27 +00:00
|
|
|
expect(blob.data).to eq('Changelog!')
|
2016-07-18 22:13:21 +00:00
|
|
|
end
|
2016-09-08 15:40:07 +00:00
|
|
|
|
|
|
|
context "when an author is specified" do
|
|
|
|
it "uses the given email/name to set the commit's author" do
|
|
|
|
expect do
|
|
|
|
repository.commit_file(user, "README", 'README!', 'Add README',
|
|
|
|
'master', true, author_email: author_email, author_name: author_name)
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
last_commit = repository.commit
|
|
|
|
|
|
|
|
expect(last_commit.author_email).to eq(author_email)
|
|
|
|
expect(last_commit.author_name).to eq(author_name)
|
|
|
|
end
|
|
|
|
end
|
2016-07-18 22:13:21 +00:00
|
|
|
end
|
|
|
|
|
2016-09-08 15:40:07 +00:00
|
|
|
describe "#update_file" do
|
2016-07-18 13:53:27 +00:00
|
|
|
it 'updates filename successfully' do
|
2016-07-18 22:13:21 +00:00
|
|
|
expect do
|
|
|
|
repository.update_file(user, 'NEWLICENSE', 'Copyright!',
|
2016-07-18 13:53:27 +00:00
|
|
|
branch: 'master',
|
|
|
|
previous_path: 'LICENSE',
|
2016-07-18 22:13:21 +00:00
|
|
|
message: 'Changes filename')
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
2016-07-18 13:53:27 +00:00
|
|
|
|
|
|
|
files = repository.ls_files('master')
|
|
|
|
|
|
|
|
expect(files).not_to include('LICENSE')
|
|
|
|
expect(files).to include('NEWLICENSE')
|
|
|
|
end
|
2016-09-08 15:40:07 +00:00
|
|
|
|
|
|
|
context "when an author is specified" do
|
|
|
|
it "uses the given email/name to set the commit's author" do
|
|
|
|
repository.commit_file(user, "README", 'README!', 'Add README', 'master', true)
|
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.update_file(user, 'README', "Updated README!",
|
|
|
|
branch: 'master',
|
|
|
|
previous_path: 'README',
|
|
|
|
message: 'Update README',
|
|
|
|
author_email: author_email,
|
|
|
|
author_name: author_name)
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
last_commit = repository.commit
|
|
|
|
|
|
|
|
expect(last_commit.author_email).to eq(author_email)
|
|
|
|
expect(last_commit.author_name).to eq(author_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "#remove_file" do
|
|
|
|
it 'removes file successfully' do
|
|
|
|
repository.commit_file(user, "README", 'README!', 'Add README', 'master', true)
|
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.remove_file(user, "README", "Remove README", 'master')
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
expect(repository.blob_at('master', 'README')).to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
context "when an author is specified" do
|
|
|
|
it "uses the given email/name to set the commit's author" do
|
|
|
|
repository.commit_file(user, "README", 'README!', 'Add README', 'master', true)
|
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.remove_file(user, "README", "Remove README", 'master', author_email: author_email, author_name: author_name)
|
|
|
|
end.to change { repository.commits('master').count }.by(1)
|
|
|
|
|
|
|
|
last_commit = repository.commit
|
|
|
|
|
|
|
|
expect(last_commit.author_email).to eq(author_email)
|
|
|
|
expect(last_commit.author_name).to eq(author_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#get_committer_and_author' do
|
|
|
|
it 'returns the committer and author data' do
|
|
|
|
options = repository.get_committer_and_author(user)
|
|
|
|
expect(options[:committer][:email]).to eq(user.email)
|
|
|
|
expect(options[:author][:email]).to eq(user.email)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the email/name are given' do
|
|
|
|
it 'returns an object containing the email/name' do
|
|
|
|
options = repository.get_committer_and_author(user, email: author_email, name: author_name)
|
|
|
|
expect(options[:author][:email]).to eq(author_email)
|
|
|
|
expect(options[:author][:name]).to eq(author_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the email is given but the name is not' do
|
|
|
|
it 'returns the committer as the author' do
|
|
|
|
options = repository.get_committer_and_author(user, email: author_email)
|
|
|
|
expect(options[:author][:email]).to eq(user.email)
|
|
|
|
expect(options[:author][:name]).to eq(user.name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the name is given but the email is not' do
|
|
|
|
it 'returns nil' do
|
|
|
|
options = repository.get_committer_and_author(user, name: author_name)
|
|
|
|
expect(options[:author][:email]).to eq(user.email)
|
|
|
|
expect(options[:author][:name]).to eq(user.name)
|
|
|
|
end
|
|
|
|
end
|
2016-07-18 13:53:27 +00:00
|
|
|
end
|
|
|
|
|
2015-07-12 12:32:25 +00:00
|
|
|
describe "search_files" do
|
|
|
|
let(:results) { repository.search_files('feature', 'master') }
|
|
|
|
subject { results }
|
|
|
|
|
|
|
|
it { is_expected.to be_an Array }
|
|
|
|
|
2016-04-09 22:40:15 +00:00
|
|
|
it 'regex-escapes the query string' do
|
|
|
|
results = repository.search_files("test\\", 'master')
|
|
|
|
|
|
|
|
expect(results.first).not_to start_with('fatal:')
|
|
|
|
end
|
|
|
|
|
2016-05-18 22:03:12 +00:00
|
|
|
it 'properly handles an unmatched parenthesis' do
|
|
|
|
results = repository.search_files("test(", 'master')
|
|
|
|
|
|
|
|
expect(results.first).not_to start_with('fatal:')
|
|
|
|
end
|
|
|
|
|
2015-07-12 12:32:25 +00:00
|
|
|
describe 'result' do
|
|
|
|
subject { results.first }
|
|
|
|
|
|
|
|
it { is_expected.to be_an String }
|
2016-09-27 15:39:29 +00:00
|
|
|
it { expect(subject.lines[2]).to eq("master:CHANGELOG:190: - Feature: Replace teams with group membership\n") }
|
2015-07-12 12:32:25 +00:00
|
|
|
end
|
|
|
|
end
|
2015-10-01 18:34:23 +00:00
|
|
|
|
2016-10-03 13:39:12 +00:00
|
|
|
describe '#create_ref' do
|
|
|
|
it 'redirects the call to fetch_ref' do
|
|
|
|
ref, ref_path = '1', '2'
|
|
|
|
|
|
|
|
expect(repository).to receive(:fetch_ref).with(repository.path_to_repo, ref, ref_path)
|
|
|
|
|
|
|
|
repository.create_ref(ref, ref_path)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-04-16 22:13:59 +00:00
|
|
|
describe "#changelog" do
|
|
|
|
before do
|
|
|
|
repository.send(:cache).expire(:changelog)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'accepts changelog' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changelog')])
|
|
|
|
|
|
|
|
expect(repository.changelog.name).to eq('changelog')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'accepts news instead of changelog' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('news')])
|
|
|
|
|
|
|
|
expect(repository.changelog.name).to eq('news')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'accepts history instead of changelog' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('history')])
|
|
|
|
|
|
|
|
expect(repository.changelog.name).to eq('history')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'accepts changes instead of changelog' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changes')])
|
|
|
|
|
|
|
|
expect(repository.changelog.name).to eq('changes')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'is case-insensitive' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('CHANGELOG')])
|
|
|
|
|
|
|
|
expect(repository.changelog.name).to eq('CHANGELOG')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe "#license_blob" do
|
2015-11-12 16:00:39 +00:00
|
|
|
before do
|
2016-04-11 13:49:25 +00:00
|
|
|
repository.send(:cache).expire(:license_blob)
|
|
|
|
repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'master')
|
2015-11-12 16:00:39 +00:00
|
|
|
end
|
|
|
|
|
2016-05-14 15:47:56 +00:00
|
|
|
it 'handles when HEAD points to non-existent ref' do
|
|
|
|
repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
|
|
|
|
rugged = double('rugged')
|
|
|
|
expect(rugged).to receive(:head_unborn?).and_return(true)
|
|
|
|
expect(repository).to receive(:rugged).and_return(rugged)
|
|
|
|
|
|
|
|
expect(repository.license_blob).to be_nil
|
|
|
|
end
|
|
|
|
|
2016-04-11 13:49:25 +00:00
|
|
|
it 'looks in the root_ref only' do
|
|
|
|
repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'markdown')
|
|
|
|
repository.commit_file(user, 'LICENSE', Licensee::License.new('mit').content, 'Add LICENSE', 'markdown', false)
|
|
|
|
|
|
|
|
expect(repository.license_blob).to be_nil
|
|
|
|
end
|
|
|
|
|
2016-04-22 13:03:54 +00:00
|
|
|
it 'detects license file with no recognizable open-source license content' do
|
|
|
|
repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
|
2016-04-11 13:49:25 +00:00
|
|
|
|
|
|
|
expect(repository.license_blob.name).to eq('LICENSE')
|
|
|
|
end
|
|
|
|
|
2016-04-22 13:03:54 +00:00
|
|
|
%w[LICENSE LICENCE LiCensE LICENSE.md LICENSE.foo COPYING COPYING.md].each do |filename|
|
|
|
|
it "detects '#{filename}'" do
|
|
|
|
repository.commit_file(user, filename, Licensee::License.new('mit').content, "Add #{filename}", 'master', false)
|
2016-04-11 13:49:25 +00:00
|
|
|
|
2016-04-22 13:03:54 +00:00
|
|
|
expect(repository.license_blob.name).to eq(filename)
|
|
|
|
end
|
2016-04-11 13:49:25 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#license_key' do
|
|
|
|
before do
|
|
|
|
repository.send(:cache).expire(:license_key)
|
|
|
|
repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'master')
|
|
|
|
end
|
2015-10-01 18:34:23 +00:00
|
|
|
|
2016-05-14 15:47:56 +00:00
|
|
|
it 'handles when HEAD points to non-existent ref' do
|
|
|
|
repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
|
|
|
|
rugged = double('rugged')
|
|
|
|
expect(rugged).to receive(:head_unborn?).and_return(true)
|
|
|
|
expect(repository).to receive(:rugged).and_return(rugged)
|
|
|
|
|
|
|
|
expect(repository.license_key).to be_nil
|
|
|
|
end
|
|
|
|
|
2016-04-22 13:03:54 +00:00
|
|
|
it 'returns nil when no license is detected' do
|
|
|
|
expect(repository.license_key).to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'detects license file with no recognizable open-source license content' do
|
|
|
|
repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
|
|
|
|
|
|
|
|
expect(repository.license_key).to be_nil
|
2015-10-01 18:34:23 +00:00
|
|
|
end
|
2015-11-12 16:00:39 +00:00
|
|
|
|
2016-04-11 13:49:25 +00:00
|
|
|
it 'returns the license key' do
|
|
|
|
repository.commit_file(user, 'LICENSE', Licensee::License.new('mit').content, 'Add LICENSE', 'master', false)
|
2015-11-12 16:00:39 +00:00
|
|
|
|
2016-04-11 13:49:25 +00:00
|
|
|
expect(repository.license_key).to eq('mit')
|
2015-11-12 16:00:39 +00:00
|
|
|
end
|
2015-10-01 18:34:23 +00:00
|
|
|
end
|
2015-12-10 15:27:26 +00:00
|
|
|
|
2016-03-24 14:35:49 +00:00
|
|
|
describe "#gitlab_ci_yml" do
|
|
|
|
it 'returns valid file' do
|
|
|
|
files = [TestBlob.new('file'), TestBlob.new('.gitlab-ci.yml'), TestBlob.new('copying')]
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return(files)
|
|
|
|
|
|
|
|
expect(repository.gitlab_ci_yml.name).to eq('.gitlab-ci.yml')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns nil if not exists' do
|
|
|
|
expect(repository.tree).to receive(:blobs).and_return([])
|
|
|
|
expect(repository.gitlab_ci_yml).to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns nil for empty repository' do
|
|
|
|
expect(repository).to receive(:empty?).and_return(true)
|
|
|
|
expect(repository.gitlab_ci_yml).to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#add_branch' do
|
2015-11-26 00:20:40 +00:00
|
|
|
context 'when pre hooks were successful' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'runs without errors' do
|
2016-07-04 12:30:22 +00:00
|
|
|
hook = double(trigger: [true, nil])
|
2015-12-01 05:22:45 +00:00
|
|
|
expect(Gitlab::Git::Hook).to receive(:new).exactly(3).times.and_return(hook)
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect { repository.add_branch(user, 'new_feature', 'master') }.not_to raise_error
|
|
|
|
end
|
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'creates the branch' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
branch = repository.add_branch(user, 'new_feature', 'master')
|
|
|
|
|
|
|
|
expect(branch.name).to eq('new_feature')
|
|
|
|
end
|
2016-03-08 17:04:00 +00:00
|
|
|
|
|
|
|
it 'calls the after_create_branch hook' do
|
|
|
|
expect(repository).to receive(:after_create_branch)
|
|
|
|
|
|
|
|
repository.add_branch(user, 'new_feature', 'master')
|
|
|
|
end
|
2015-11-26 00:20:40 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pre hooks failed' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'gets an error' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.add_branch(user, 'new_feature', 'master')
|
|
|
|
end.to raise_error(GitHooksService::PreReceiveError)
|
|
|
|
end
|
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'does not create the branch' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.add_branch(user, 'new_feature', 'master')
|
|
|
|
end.to raise_error(GitHooksService::PreReceiveError)
|
|
|
|
expect(repository.find_branch('new_feature')).to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-08-29 14:46:30 +00:00
|
|
|
describe '#find_branch' do
|
|
|
|
it 'loads a branch with a fresh repo' do
|
|
|
|
expect(Gitlab::Git::Repository).to receive(:new).twice.and_call_original
|
|
|
|
|
|
|
|
2.times do
|
|
|
|
expect(repository.find_branch('feature')).not_to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'loads a branch with a cached repo' do
|
|
|
|
expect(Gitlab::Git::Repository).to receive(:new).once.and_call_original
|
|
|
|
|
|
|
|
2.times do
|
|
|
|
expect(repository.find_branch('feature', fresh_repo: false)).not_to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-07-11 22:12:31 +00:00
|
|
|
describe '#rm_branch' do
|
2016-07-27 15:26:29 +00:00
|
|
|
let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature
|
|
|
|
let(:blank_sha) { '0000000000000000000000000000000000000000' }
|
|
|
|
|
2015-11-26 00:20:40 +00:00
|
|
|
context 'when pre hooks were successful' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'runs without errors' do
|
2016-07-27 15:26:29 +00:00
|
|
|
expect_any_instance_of(GitHooksService).to receive(:execute).
|
|
|
|
with(user, project.repository.path_to_repo, old_rev, blank_sha, 'refs/heads/feature')
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect { repository.rm_branch(user, 'feature') }.not_to raise_error
|
|
|
|
end
|
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'deletes the branch' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect { repository.rm_branch(user, 'feature') }.not_to raise_error
|
|
|
|
|
|
|
|
expect(repository.find_branch('feature')).to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when pre hooks failed' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'gets an error' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.rm_branch(user, 'new_feature')
|
|
|
|
end.to raise_error(GitHooksService::PreReceiveError)
|
|
|
|
end
|
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'does not delete the branch' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect do
|
|
|
|
repository.rm_branch(user, 'feature')
|
|
|
|
end.to raise_error(GitHooksService::PreReceiveError)
|
|
|
|
expect(repository.find_branch('feature')).not_to be_nil
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-07 14:28:26 +00:00
|
|
|
describe '#update_branch_with_hooks' do
|
2016-07-27 15:26:29 +00:00
|
|
|
let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature
|
2016-08-30 14:06:40 +00:00
|
|
|
let(:new_rev) { 'a74ae73c1ccde9b974a70e82b901588071dc142a' } # commit whose parent is old_rev
|
2016-07-27 15:26:29 +00:00
|
|
|
|
2015-11-26 00:20:40 +00:00
|
|
|
context 'when pre hooks were successful' do
|
2016-02-17 15:49:16 +00:00
|
|
|
before do
|
|
|
|
expect_any_instance_of(GitHooksService).to receive(:execute).
|
2016-08-30 14:06:40 +00:00
|
|
|
with(user, repository.path_to_repo, old_rev, new_rev, 'refs/heads/feature').
|
2016-07-27 15:26:29 +00:00
|
|
|
and_yield.and_return(true)
|
2016-02-17 15:49:16 +00:00
|
|
|
end
|
2015-11-26 00:20:40 +00:00
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'runs without errors' do
|
2015-11-26 00:20:40 +00:00
|
|
|
expect do
|
2016-09-07 14:28:26 +00:00
|
|
|
repository.update_branch_with_hooks(user, 'feature') { new_rev }
|
2015-11-26 00:20:40 +00:00
|
|
|
end.not_to raise_error
|
|
|
|
end
|
2016-02-17 15:49:16 +00:00
|
|
|
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'ensures the autocrlf Git option is set to :input' do
|
2016-02-17 15:49:16 +00:00
|
|
|
expect(repository).to receive(:update_autocrlf_option)
|
|
|
|
|
2016-09-07 14:28:26 +00:00
|
|
|
repository.update_branch_with_hooks(user, 'feature') { new_rev }
|
2016-02-17 15:49:16 +00:00
|
|
|
end
|
2016-07-27 15:26:29 +00:00
|
|
|
|
|
|
|
context "when the branch wasn't empty" do
|
|
|
|
it 'updates the head' do
|
|
|
|
expect(repository.find_branch('feature').target.id).to eq(old_rev)
|
2016-09-07 14:28:26 +00:00
|
|
|
repository.update_branch_with_hooks(user, 'feature') { new_rev }
|
2016-08-30 14:06:40 +00:00
|
|
|
expect(repository.find_branch('feature').target.id).to eq(new_rev)
|
2016-07-27 15:26:29 +00:00
|
|
|
end
|
|
|
|
end
|
2015-11-26 00:20:40 +00:00
|
|
|
end
|
|
|
|
|
2016-09-07 14:26:06 +00:00
|
|
|
context 'when the update adds more than one commit' do
|
|
|
|
it 'runs without errors' do
|
2016-09-07 14:56:11 +00:00
|
|
|
old_rev = '33f3729a45c02fc67d00adb1b8bca394b0e761d9'
|
|
|
|
|
|
|
|
# old_rev is an ancestor of new_rev
|
|
|
|
expect(repository.rugged.merge_base(old_rev, new_rev)).to eq(old_rev)
|
|
|
|
|
|
|
|
# old_rev is not a direct ancestor (parent) of new_rev
|
|
|
|
expect(repository.rugged.lookup(new_rev).parent_ids).not_to include(old_rev)
|
|
|
|
|
2016-09-07 14:26:06 +00:00
|
|
|
branch = 'feature-ff-target'
|
|
|
|
repository.add_branch(user, branch, old_rev)
|
|
|
|
|
2016-09-07 14:28:26 +00:00
|
|
|
expect { repository.update_branch_with_hooks(user, branch) { new_rev } }.not_to raise_error
|
2016-09-07 14:26:06 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the update would remove commits from the target branch' do
|
|
|
|
it 'raises an exception' do
|
2016-09-07 14:56:11 +00:00
|
|
|
branch = 'master'
|
|
|
|
old_rev = repository.find_branch(branch).target.sha
|
|
|
|
|
|
|
|
# The 'master' branch is NOT an ancestor of new_rev.
|
|
|
|
expect(repository.rugged.merge_base(old_rev, new_rev)).not_to eq(old_rev)
|
|
|
|
|
|
|
|
# Updating 'master' to new_rev would lose the commits on 'master' that
|
|
|
|
# are not contained in new_rev. This should not be allowed.
|
|
|
|
expect do
|
|
|
|
repository.update_branch_with_hooks(user, branch) { new_rev }
|
|
|
|
end.to raise_error(Repository::CommitError)
|
2016-09-07 14:26:06 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-11-26 00:20:40 +00:00
|
|
|
context 'when pre hooks failed' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'gets an error' do
|
2016-07-04 12:30:22 +00:00
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
|
2015-11-26 00:20:40 +00:00
|
|
|
|
|
|
|
expect do
|
2016-09-07 14:28:26 +00:00
|
|
|
repository.update_branch_with_hooks(user, 'feature') { new_rev }
|
2015-11-26 00:20:40 +00:00
|
|
|
end.to raise_error(GitHooksService::PreReceiveError)
|
|
|
|
end
|
|
|
|
end
|
2016-07-27 09:51:37 +00:00
|
|
|
|
|
|
|
context 'when target branch is different from source branch' do
|
|
|
|
before do
|
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, ''])
|
2016-08-30 14:06:40 +00:00
|
|
|
allow(repository).to receive(:update_ref!)
|
2016-07-27 09:51:37 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'expires branch cache' do
|
|
|
|
expect(repository).not_to receive(:expire_exists_cache)
|
|
|
|
expect(repository).not_to receive(:expire_root_ref_cache)
|
|
|
|
expect(repository).not_to receive(:expire_emptiness_caches)
|
|
|
|
expect(repository).to receive(:expire_branches_cache)
|
|
|
|
expect(repository).to receive(:expire_has_visible_content_cache)
|
|
|
|
expect(repository).to receive(:expire_branch_count_cache)
|
|
|
|
|
2016-09-07 14:28:26 +00:00
|
|
|
repository.update_branch_with_hooks(user, 'new-feature') { new_rev }
|
2016-07-27 09:51:37 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when repository is empty' do
|
|
|
|
before do
|
|
|
|
allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, ''])
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'expires creation and branch cache' do
|
|
|
|
empty_repository = create(:empty_project, :empty_repo).repository
|
|
|
|
|
|
|
|
expect(empty_repository).to receive(:expire_exists_cache)
|
|
|
|
expect(empty_repository).to receive(:expire_root_ref_cache)
|
|
|
|
expect(empty_repository).to receive(:expire_emptiness_caches)
|
|
|
|
expect(empty_repository).to receive(:expire_branches_cache)
|
|
|
|
expect(empty_repository).to receive(:expire_has_visible_content_cache)
|
|
|
|
expect(empty_repository).to receive(:expire_branch_count_cache)
|
|
|
|
|
|
|
|
empty_repository.commit_file(user, 'CHANGELOG', 'Changelog!',
|
|
|
|
'Updates file content', 'master', false)
|
|
|
|
end
|
|
|
|
end
|
2015-11-26 00:20:40 +00:00
|
|
|
end
|
2016-01-21 17:19:18 +00:00
|
|
|
|
2016-02-18 11:28:47 +00:00
|
|
|
describe '#exists?' do
|
|
|
|
it 'returns true when a repository exists' do
|
|
|
|
expect(repository.exists?).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false when a repository does not exist' do
|
|
|
|
expect(repository.raw_repository).to receive(:rugged).
|
|
|
|
and_raise(Gitlab::Git::Repository::NoRepository)
|
|
|
|
|
|
|
|
expect(repository.exists?).to eq(false)
|
|
|
|
end
|
2016-02-18 13:19:35 +00:00
|
|
|
|
|
|
|
it 'returns false when there is no namespace' do
|
|
|
|
allow(repository).to receive(:path_with_namespace).and_return(nil)
|
|
|
|
|
|
|
|
expect(repository.exists?).to eq(false)
|
|
|
|
end
|
2016-02-18 11:28:47 +00:00
|
|
|
end
|
|
|
|
|
2016-01-21 17:19:18 +00:00
|
|
|
describe '#has_visible_content?' do
|
|
|
|
subject { repository.has_visible_content? }
|
|
|
|
|
|
|
|
describe 'when there are no branches' do
|
|
|
|
before do
|
2016-04-01 19:21:08 +00:00
|
|
|
allow(repository).to receive(:branch_count).and_return(0)
|
2016-01-21 17:19:18 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to eq(false) }
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when there are branches' do
|
2016-02-08 11:50:55 +00:00
|
|
|
it 'returns true' do
|
2016-04-01 19:21:08 +00:00
|
|
|
expect(repository).to receive(:branch_count).and_return(3)
|
2016-02-08 11:50:55 +00:00
|
|
|
|
|
|
|
expect(subject).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'caches the output' do
|
2016-04-01 19:21:08 +00:00
|
|
|
expect(repository).to receive(:branch_count).
|
2016-02-08 11:50:55 +00:00
|
|
|
once.
|
|
|
|
and_return(3)
|
|
|
|
|
|
|
|
repository.has_visible_content?
|
|
|
|
repository.has_visible_content?
|
2016-01-21 17:19:18 +00:00
|
|
|
end
|
2016-02-08 11:50:55 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-02-17 15:49:16 +00:00
|
|
|
describe '#update_autocrlf_option' do
|
|
|
|
describe 'when autocrlf is not already set to :input' do
|
|
|
|
before do
|
|
|
|
repository.raw_repository.autocrlf = true
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'sets autocrlf to :input' do
|
|
|
|
repository.update_autocrlf_option
|
|
|
|
|
|
|
|
expect(repository.raw_repository.autocrlf).to eq(:input)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when autocrlf is already set to :input' do
|
|
|
|
before do
|
|
|
|
repository.raw_repository.autocrlf = :input
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does nothing' do
|
2016-05-23 23:37:59 +00:00
|
|
|
expect(repository.raw_repository).not_to receive(:autocrlf=).
|
2016-02-17 15:49:16 +00:00
|
|
|
with(:input)
|
|
|
|
|
|
|
|
repository.update_autocrlf_option
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-02-08 11:50:55 +00:00
|
|
|
describe '#empty?' do
|
|
|
|
let(:empty_repository) { create(:project_empty_repo).repository }
|
|
|
|
|
|
|
|
it 'returns true for an empty repository' do
|
|
|
|
expect(empty_repository.empty?).to eq(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a non-empty repository' do
|
|
|
|
expect(repository.empty?).to eq(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'caches the output' do
|
|
|
|
expect(repository.raw_repository).to receive(:empty?).
|
|
|
|
once.
|
|
|
|
and_return(false)
|
|
|
|
|
|
|
|
repository.empty?
|
|
|
|
repository.empty?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#root_ref' do
|
|
|
|
it 'returns a branch name' do
|
|
|
|
expect(repository.root_ref).to be_an_instance_of(String)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'caches the output' do
|
|
|
|
expect(repository.raw_repository).to receive(:root_ref).
|
|
|
|
once.
|
|
|
|
and_return('master')
|
|
|
|
|
|
|
|
repository.root_ref
|
|
|
|
repository.root_ref
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_cache' do
|
|
|
|
it 'expires all caches' do
|
|
|
|
expect(repository).to receive(:expire_branch_cache)
|
|
|
|
|
|
|
|
repository.expire_cache
|
|
|
|
end
|
2016-02-09 13:59:11 +00:00
|
|
|
|
|
|
|
it 'expires the caches for a specific branch' do
|
|
|
|
expect(repository).to receive(:expire_branch_cache).with('master')
|
|
|
|
|
|
|
|
repository.expire_cache('master')
|
|
|
|
end
|
2016-02-20 15:23:54 +00:00
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
it 'expires the emptiness caches for an empty repository' do
|
2016-02-20 15:23:54 +00:00
|
|
|
expect(repository).to receive(:empty?).and_return(true)
|
|
|
|
expect(repository).to receive(:expire_emptiness_caches)
|
|
|
|
|
|
|
|
repository.expire_cache
|
|
|
|
end
|
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
it 'does not expire the emptiness caches for a non-empty repository' do
|
2016-02-20 15:23:54 +00:00
|
|
|
expect(repository).to receive(:empty?).and_return(false)
|
2016-05-23 23:37:59 +00:00
|
|
|
expect(repository).not_to receive(:expire_emptiness_caches)
|
2016-02-20 15:23:54 +00:00
|
|
|
|
|
|
|
repository.expire_cache
|
|
|
|
end
|
2016-02-08 11:50:55 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_root_ref_cache' do
|
|
|
|
it 'expires the root reference cache' do
|
|
|
|
repository.root_ref
|
|
|
|
|
|
|
|
expect(repository.raw_repository).to receive(:root_ref).
|
|
|
|
once.
|
|
|
|
and_return('foo')
|
|
|
|
|
|
|
|
repository.expire_root_ref_cache
|
|
|
|
|
|
|
|
expect(repository.root_ref).to eq('foo')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_has_visible_content_cache' do
|
|
|
|
it 'expires the visible content cache' do
|
|
|
|
repository.has_visible_content?
|
|
|
|
|
2016-04-01 19:21:08 +00:00
|
|
|
expect(repository).to receive(:branch_count).
|
2016-02-08 11:50:55 +00:00
|
|
|
once.
|
|
|
|
and_return(0)
|
|
|
|
|
|
|
|
repository.expire_has_visible_content_cache
|
2016-01-21 17:19:18 +00:00
|
|
|
|
2016-02-08 11:50:55 +00:00
|
|
|
expect(repository.has_visible_content?).to eq(false)
|
2016-01-21 17:19:18 +00:00
|
|
|
end
|
|
|
|
end
|
2016-02-09 13:59:11 +00:00
|
|
|
|
2016-03-08 16:38:23 +00:00
|
|
|
describe '#expire_branch_cache' do
|
2016-02-09 13:59:11 +00:00
|
|
|
# This method is private but we need it for testing purposes. Sadly there's
|
|
|
|
# no other proper way of testing caching operations.
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'expires the cache for all branches' do
|
|
|
|
expect(cache).to receive(:expire).
|
|
|
|
at_least(repository.branches.length).
|
|
|
|
times
|
|
|
|
|
|
|
|
repository.expire_branch_cache
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'expires the cache for all branches when the root branch is given' do
|
|
|
|
expect(cache).to receive(:expire).
|
|
|
|
at_least(repository.branches.length).
|
|
|
|
times
|
|
|
|
|
|
|
|
repository.expire_branch_cache(repository.root_ref)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'expires the cache for a specific branch' do
|
|
|
|
expect(cache).to receive(:expire).once
|
|
|
|
|
|
|
|
repository.expire_branch_cache('foo')
|
|
|
|
end
|
|
|
|
end
|
2015-12-11 13:47:57 +00:00
|
|
|
|
2016-02-16 16:31:37 +00:00
|
|
|
describe '#expire_emptiness_caches' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'expires the caches' do
|
|
|
|
expect(cache).to receive(:expire).with(:empty?)
|
|
|
|
expect(repository).to receive(:expire_has_visible_content_cache)
|
|
|
|
|
|
|
|
repository.expire_emptiness_caches
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-12-11 13:47:57 +00:00
|
|
|
describe :skip_merged_commit do
|
2016-04-22 12:07:25 +00:00
|
|
|
subject { repository.commits(Gitlab::Git::BRANCH_REF_PREFIX + "'test'", limit: 100, skip_merges: true).map{ |k| k.id } }
|
2015-12-11 13:47:57 +00:00
|
|
|
|
|
|
|
it { is_expected.not_to include('e56497bb5f03a90a51293fc6d516788730953899') }
|
|
|
|
end
|
2016-02-02 01:24:52 +00:00
|
|
|
|
|
|
|
describe '#merge' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'merges the code and return the commit id' do
|
2016-02-10 23:02:46 +00:00
|
|
|
expect(merge_commit).to be_present
|
|
|
|
expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
|
2016-02-02 01:24:52 +00:00
|
|
|
end
|
2016-08-19 05:48:49 +00:00
|
|
|
|
|
|
|
it 'sets the `in_progress_merge_commit_sha` flag for the given merge request' do
|
|
|
|
merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
|
|
|
|
merge_commit_id = repository.merge(user, merge_request, commit_options)
|
|
|
|
repository.commit(merge_commit_id)
|
|
|
|
|
|
|
|
expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
|
|
|
|
end
|
2016-02-02 01:24:52 +00:00
|
|
|
end
|
|
|
|
|
2016-03-02 00:14:52 +00:00
|
|
|
describe '#revert' do
|
|
|
|
let(:new_image_commit) { repository.commit('33f3729a45c02fc67d00adb1b8bca394b0e761d9') }
|
|
|
|
let(:update_image_commit) { repository.commit('2f63565e7aac07bcdadb654e253078b727143ec4') }
|
2016-02-02 01:24:52 +00:00
|
|
|
|
2016-03-02 00:14:52 +00:00
|
|
|
context 'when there is a conflict' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'aborts the operation' do
|
2016-03-02 00:14:52 +00:00
|
|
|
expect(repository.revert(user, new_image_commit, 'master')).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when commit was already reverted' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'aborts the operation' do
|
2016-03-02 00:14:52 +00:00
|
|
|
repository.revert(user, update_image_commit, 'master')
|
|
|
|
|
|
|
|
expect(repository.revert(user, update_image_commit, 'master')).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when commit can be reverted' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'reverts the changes' do
|
2016-03-02 00:14:52 +00:00
|
|
|
expect(repository.revert(user, update_image_commit, 'master')).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'reverting a merge commit' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'reverts the changes' do
|
2016-03-02 00:14:52 +00:00
|
|
|
merge_commit
|
|
|
|
expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).to be_present
|
|
|
|
|
|
|
|
repository.revert(user, merge_commit, 'master')
|
|
|
|
expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).not_to be_present
|
|
|
|
end
|
2016-02-02 01:24:52 +00:00
|
|
|
end
|
|
|
|
end
|
2016-02-25 11:56:04 +00:00
|
|
|
|
2016-04-18 07:39:07 +00:00
|
|
|
describe '#cherry_pick' do
|
|
|
|
let(:conflict_commit) { repository.commit('c642fe9b8b9f28f9225d7ea953fe14e74748d53b') }
|
|
|
|
let(:pickable_commit) { repository.commit('7d3b0f7cff5f37573aea97cebfd5692ea1689924') }
|
|
|
|
let(:pickable_merge) { repository.commit('e56497bb5f03a90a51293fc6d516788730953899') }
|
|
|
|
|
|
|
|
context 'when there is a conflict' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'aborts the operation' do
|
2016-04-18 07:39:07 +00:00
|
|
|
expect(repository.cherry_pick(user, conflict_commit, 'master')).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when commit was already cherry-picked' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'aborts the operation' do
|
2016-04-18 07:39:07 +00:00
|
|
|
repository.cherry_pick(user, pickable_commit, 'master')
|
|
|
|
|
|
|
|
expect(repository.cherry_pick(user, pickable_commit, 'master')).to eq(false)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'when commit can be cherry-picked' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'cherry-picks the changes' do
|
2016-04-18 07:39:07 +00:00
|
|
|
expect(repository.cherry_pick(user, pickable_commit, 'master')).to be_truthy
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'cherry-picking a merge commit' do
|
2016-08-01 15:00:44 +00:00
|
|
|
it 'cherry-picks the changes' do
|
2016-09-27 15:39:29 +00:00
|
|
|
expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).to be_nil
|
2016-04-18 07:39:07 +00:00
|
|
|
|
2016-09-27 15:39:29 +00:00
|
|
|
repository.cherry_pick(user, pickable_merge, 'improve/awesome')
|
|
|
|
expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).not_to be_nil
|
2016-04-18 07:39:07 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
describe '#before_delete' do
|
|
|
|
describe 'when a repository does not exist' do
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:exists?).and_return(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not flush caches that depend on repository data' do
|
2016-05-23 23:37:59 +00:00
|
|
|
expect(repository).not_to receive(:expire_cache)
|
2016-02-25 11:56:04 +00:00
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
2016-07-20 07:31:56 +00:00
|
|
|
it 'flushes the tags cache' do
|
|
|
|
expect(repository).to receive(:expire_tags_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the tag count cache' do
|
|
|
|
expect(repository).to receive(:expire_tag_count_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the branches cache' do
|
|
|
|
expect(repository).to receive(:expire_branches_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the branch count cache' do
|
|
|
|
expect(repository).to receive(:expire_branch_count_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
it 'flushes the root ref cache' do
|
|
|
|
expect(repository).to receive(:expire_root_ref_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the emptiness caches' do
|
|
|
|
expect(repository).to receive(:expire_emptiness_caches)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
2016-03-18 14:31:19 +00:00
|
|
|
|
|
|
|
it 'flushes the exists cache' do
|
2016-03-27 12:54:12 +00:00
|
|
|
expect(repository).to receive(:expire_exists_cache).twice
|
2016-03-18 14:31:19 +00:00
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
2016-02-25 11:56:04 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
describe 'when a repository exists' do
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:exists?).and_return(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the caches that depend on repository data' do
|
|
|
|
expect(repository).to receive(:expire_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
2016-07-20 07:31:56 +00:00
|
|
|
it 'flushes the tags cache' do
|
|
|
|
expect(repository).to receive(:expire_tags_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the tag count cache' do
|
|
|
|
expect(repository).to receive(:expire_tag_count_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the branches cache' do
|
|
|
|
expect(repository).to receive(:expire_branches_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the branch count cache' do
|
|
|
|
expect(repository).to receive(:expire_branch_count_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
it 'flushes the root ref cache' do
|
|
|
|
expect(repository).to receive(:expire_root_ref_cache)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the emptiness caches' do
|
|
|
|
expect(repository).to receive(:expire_emptiness_caches)
|
|
|
|
|
|
|
|
repository.before_delete
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#before_change_head' do
|
|
|
|
it 'flushes the branch cache' do
|
|
|
|
expect(repository).to receive(:expire_branch_cache)
|
|
|
|
|
|
|
|
repository.before_change_head
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the root ref cache' do
|
|
|
|
expect(repository).to receive(:expire_root_ref_cache)
|
|
|
|
|
|
|
|
repository.before_change_head
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-03-08 16:38:23 +00:00
|
|
|
describe '#before_push_tag' do
|
2016-02-25 11:56:04 +00:00
|
|
|
it 'flushes the cache' do
|
|
|
|
expect(repository).to receive(:expire_cache)
|
2016-03-08 16:38:23 +00:00
|
|
|
expect(repository).to receive(:expire_tag_count_cache)
|
2016-02-25 11:56:04 +00:00
|
|
|
|
2016-03-08 16:38:23 +00:00
|
|
|
repository.before_push_tag
|
2016-02-25 11:56:04 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-04-04 22:35:39 +00:00
|
|
|
describe '#before_import' do
|
2016-10-23 17:31:18 +00:00
|
|
|
it 'flushes the repository caches' do
|
|
|
|
expect(repository).to receive(:expire_content_cache)
|
2016-04-04 22:35:39 +00:00
|
|
|
|
|
|
|
repository.before_import
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-02-25 11:56:04 +00:00
|
|
|
describe '#after_import' do
|
2016-10-23 17:31:18 +00:00
|
|
|
it 'flushes and builds the cache' do
|
|
|
|
expect(repository).to receive(:expire_content_cache)
|
|
|
|
expect(repository).to receive(:build_cache)
|
2016-03-18 14:31:19 +00:00
|
|
|
|
|
|
|
repository.after_import
|
|
|
|
end
|
2016-02-25 11:56:04 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
describe '#after_push_commit' do
|
|
|
|
it 'flushes the cache' do
|
2016-03-17 15:53:05 +00:00
|
|
|
expect(repository).to receive(:expire_cache).with('master', '123')
|
2016-02-25 11:56:04 +00:00
|
|
|
|
2016-03-17 15:53:05 +00:00
|
|
|
repository.after_push_commit('master', '123')
|
2016-02-25 11:56:04 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#after_create_branch' do
|
|
|
|
it 'flushes the visible content cache' do
|
|
|
|
expect(repository).to receive(:expire_has_visible_content_cache)
|
|
|
|
|
|
|
|
repository.after_create_branch
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#after_remove_branch' do
|
|
|
|
it 'flushes the visible content cache' do
|
|
|
|
expect(repository).to receive(:expire_has_visible_content_cache)
|
|
|
|
|
|
|
|
repository.after_remove_branch
|
|
|
|
end
|
|
|
|
end
|
2016-03-01 19:45:55 +00:00
|
|
|
|
2016-03-18 14:31:19 +00:00
|
|
|
describe '#after_create' do
|
|
|
|
it 'flushes the exists cache' do
|
|
|
|
expect(repository).to receive(:expire_exists_cache)
|
|
|
|
|
|
|
|
repository.after_create
|
|
|
|
end
|
2016-04-07 07:23:02 +00:00
|
|
|
|
|
|
|
it 'flushes the root ref cache' do
|
|
|
|
expect(repository).to receive(:expire_root_ref_cache)
|
|
|
|
|
|
|
|
repository.after_create
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the emptiness caches' do
|
|
|
|
expect(repository).to receive(:expire_emptiness_caches)
|
|
|
|
|
|
|
|
repository.after_create
|
|
|
|
end
|
2016-03-18 14:31:19 +00:00
|
|
|
end
|
|
|
|
|
2016-03-14 23:33:00 +00:00
|
|
|
describe "#copy_gitattributes" do
|
|
|
|
it 'returns true with a valid ref' do
|
|
|
|
expect(repository.copy_gitattributes('master')).to be_truthy
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false with an invalid ref' do
|
|
|
|
expect(repository.copy_gitattributes('invalid')).to be_falsey
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-03-08 16:38:23 +00:00
|
|
|
describe '#before_remove_tag' do
|
|
|
|
it 'flushes the tag cache' do
|
|
|
|
expect(repository).to receive(:expire_tag_count_cache)
|
|
|
|
|
|
|
|
repository.before_remove_tag
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#branch_count' do
|
|
|
|
it 'returns the number of branches' do
|
|
|
|
expect(repository.branch_count).to be_an_instance_of(Fixnum)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#tag_count' do
|
|
|
|
it 'returns the number of tags' do
|
|
|
|
expect(repository.tag_count).to be_an_instance_of(Fixnum)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_branch_count_cache' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'expires the cache' do
|
|
|
|
expect(cache).to receive(:expire).with(:branch_count)
|
|
|
|
|
|
|
|
repository.expire_branch_count_cache
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_tag_count_cache' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'expires the cache' do
|
|
|
|
expect(cache).to receive(:expire).with(:tag_count)
|
|
|
|
|
|
|
|
repository.expire_tag_count_cache
|
|
|
|
end
|
|
|
|
end
|
2016-03-08 16:53:00 +00:00
|
|
|
|
2016-03-08 17:01:16 +00:00
|
|
|
describe '#add_tag' do
|
2016-04-25 14:31:45 +00:00
|
|
|
context 'with a valid target' do
|
|
|
|
let(:user) { build_stubbed(:user) }
|
2016-03-08 17:01:16 +00:00
|
|
|
|
2016-04-25 14:31:45 +00:00
|
|
|
it 'creates the tag using rugged' do
|
|
|
|
expect(repository.rugged.tags).to receive(:create).
|
|
|
|
with('8.5', repository.commit('master').id,
|
|
|
|
hash_including(message: 'foo',
|
|
|
|
tagger: hash_including(name: user.name, email: user.email))).
|
|
|
|
and_call_original
|
2016-03-08 17:01:16 +00:00
|
|
|
|
2016-04-25 14:31:45 +00:00
|
|
|
repository.add_tag(user, '8.5', 'master', 'foo')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns a Gitlab::Git::Tag object' do
|
|
|
|
tag = repository.add_tag(user, '8.5', 'master', 'foo')
|
|
|
|
|
|
|
|
expect(tag).to be_a(Gitlab::Git::Tag)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with an invalid target' do
|
|
|
|
it 'returns false' do
|
|
|
|
expect(repository.add_tag(user, '8.5', 'bar', 'foo')).to be false
|
|
|
|
end
|
2016-03-08 17:01:16 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-03-08 16:53:00 +00:00
|
|
|
describe '#rm_branch' do
|
|
|
|
let(:user) { create(:user) }
|
|
|
|
|
|
|
|
it 'removes a branch' do
|
|
|
|
expect(repository).to receive(:before_remove_branch)
|
|
|
|
expect(repository).to receive(:after_remove_branch)
|
|
|
|
|
|
|
|
repository.rm_branch(user, 'feature')
|
|
|
|
end
|
|
|
|
end
|
2016-03-08 16:53:23 +00:00
|
|
|
|
|
|
|
describe '#rm_tag' do
|
|
|
|
it 'removes a tag' do
|
|
|
|
expect(repository).to receive(:before_remove_tag)
|
2016-04-15 12:21:28 +00:00
|
|
|
expect(repository.rugged.tags).to receive(:delete).with('v1.1.0')
|
2016-03-08 16:53:23 +00:00
|
|
|
|
2016-04-15 12:21:28 +00:00
|
|
|
repository.rm_tag('v1.1.0')
|
2016-03-08 16:53:23 +00:00
|
|
|
end
|
|
|
|
end
|
2016-03-17 15:53:05 +00:00
|
|
|
|
|
|
|
describe '#avatar' do
|
2016-03-24 16:29:00 +00:00
|
|
|
it 'returns nil if repo does not exist' do
|
|
|
|
expect(repository).to receive(:exists?).and_return(false)
|
|
|
|
|
|
|
|
expect(repository.avatar).to eq(nil)
|
|
|
|
end
|
|
|
|
|
2016-03-17 15:53:05 +00:00
|
|
|
it 'returns the first avatar file found in the repository' do
|
|
|
|
expect(repository).to receive(:blob_at_branch).
|
|
|
|
with('master', 'logo.png').
|
|
|
|
and_return(true)
|
|
|
|
|
|
|
|
expect(repository.avatar).to eq('logo.png')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'caches the output' do
|
|
|
|
allow(repository).to receive(:blob_at_branch).
|
|
|
|
with('master', 'logo.png').
|
|
|
|
and_return(true)
|
|
|
|
|
|
|
|
expect(repository.avatar).to eq('logo.png')
|
|
|
|
|
2016-05-23 23:37:59 +00:00
|
|
|
expect(repository).not_to receive(:blob_at_branch)
|
2016-03-17 15:53:05 +00:00
|
|
|
expect(repository.avatar).to eq('logo.png')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#expire_avatar_cache' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:cache).and_return(cache)
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'without a branch or revision' do
|
|
|
|
it 'flushes the cache' do
|
|
|
|
expect(cache).to receive(:expire).with(:avatar)
|
|
|
|
|
|
|
|
repository.expire_avatar_cache
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with a branch' do
|
|
|
|
it 'does not flush the cache if the branch is not the default branch' do
|
|
|
|
expect(cache).not_to receive(:expire)
|
|
|
|
|
|
|
|
repository.expire_avatar_cache('cats')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the cache if the branch equals the default branch' do
|
|
|
|
expect(cache).to receive(:expire).with(:avatar)
|
|
|
|
|
|
|
|
repository.expire_avatar_cache(repository.root_ref)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with a branch and revision' do
|
|
|
|
let(:commit) { double(:commit) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:commit).and_return(commit)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not flush the cache if the commit does not change any logos' do
|
|
|
|
diff = double(:diff, new_path: 'test.txt')
|
|
|
|
|
2016-07-27 17:00:34 +00:00
|
|
|
expect(commit).to receive(:raw_diffs).and_return([diff])
|
2016-03-17 15:53:05 +00:00
|
|
|
expect(cache).not_to receive(:expire)
|
|
|
|
|
|
|
|
repository.expire_avatar_cache(repository.root_ref, '123')
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'flushes the cache if the commit changes any of the logos' do
|
|
|
|
diff = double(:diff, new_path: Repository::AVATAR_FILES[0])
|
|
|
|
|
2016-07-27 17:00:34 +00:00
|
|
|
expect(commit).to receive(:raw_diffs).and_return([diff])
|
2016-03-17 15:53:05 +00:00
|
|
|
expect(cache).to receive(:expire).with(:avatar)
|
|
|
|
|
|
|
|
repository.expire_avatar_cache(repository.root_ref, '123')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2016-03-17 17:15:09 +00:00
|
|
|
|
2016-03-18 14:31:19 +00:00
|
|
|
describe '#expire_exists_cache' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'expires the cache' do
|
|
|
|
expect(cache).to receive(:expire).with(:exists?)
|
|
|
|
|
|
|
|
repository.expire_exists_cache
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-03-17 17:15:09 +00:00
|
|
|
describe '#build_cache' do
|
|
|
|
let(:cache) { repository.send(:cache) }
|
|
|
|
|
|
|
|
it 'builds the caches if they do not already exist' do
|
2016-06-28 09:39:29 +00:00
|
|
|
cache_keys = repository.cache_keys + repository.cache_keys_for_branches_and_tags
|
|
|
|
|
2016-03-17 17:15:09 +00:00
|
|
|
expect(cache).to receive(:exist?).
|
2016-06-28 09:39:29 +00:00
|
|
|
exactly(cache_keys.length).
|
2016-03-17 17:15:09 +00:00
|
|
|
times.
|
|
|
|
and_return(false)
|
|
|
|
|
2016-06-28 09:39:29 +00:00
|
|
|
cache_keys.each do |key|
|
2016-03-17 17:15:09 +00:00
|
|
|
expect(repository).to receive(key)
|
|
|
|
end
|
|
|
|
|
|
|
|
repository.build_cache
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not build any caches that already exist' do
|
2016-06-28 09:39:29 +00:00
|
|
|
cache_keys = repository.cache_keys + repository.cache_keys_for_branches_and_tags
|
|
|
|
|
2016-03-17 17:15:09 +00:00
|
|
|
expect(cache).to receive(:exist?).
|
2016-06-28 09:39:29 +00:00
|
|
|
exactly(cache_keys.length).
|
2016-03-17 17:15:09 +00:00
|
|
|
times.
|
|
|
|
and_return(true)
|
|
|
|
|
2016-06-28 09:39:29 +00:00
|
|
|
cache_keys.each do |key|
|
2016-05-23 23:37:59 +00:00
|
|
|
expect(repository).not_to receive(key)
|
2016-03-17 17:15:09 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
repository.build_cache
|
|
|
|
end
|
|
|
|
end
|
2016-04-01 19:21:08 +00:00
|
|
|
|
2016-07-03 23:58:58 +00:00
|
|
|
describe "#keep_around" do
|
2016-07-22 13:38:02 +00:00
|
|
|
it "does not fail if we attempt to reference bad commit" do
|
|
|
|
expect(repository.kept_around?('abc1234')).to be_falsey
|
|
|
|
end
|
|
|
|
|
2016-07-03 23:58:58 +00:00
|
|
|
it "stores a reference to the specified commit sha so it isn't garbage collected" do
|
|
|
|
repository.keep_around(sample_commit.id)
|
|
|
|
|
|
|
|
expect(repository.kept_around?(sample_commit.id)).to be_truthy
|
|
|
|
end
|
2016-07-22 13:38:02 +00:00
|
|
|
|
|
|
|
it "attempting to call keep_around on truncated ref does not fail" do
|
|
|
|
repository.keep_around(sample_commit.id)
|
|
|
|
ref = repository.send(:keep_around_ref_name, sample_commit.id)
|
|
|
|
path = File.join(repository.path, ref)
|
|
|
|
# Corrupt the reference
|
|
|
|
File.truncate(path, 0)
|
|
|
|
|
|
|
|
expect(repository.kept_around?(sample_commit.id)).to be_falsey
|
|
|
|
|
|
|
|
repository.keep_around(sample_commit.id)
|
|
|
|
|
|
|
|
expect(repository.kept_around?(sample_commit.id)).to be_falsey
|
|
|
|
|
|
|
|
File.delete(path)
|
|
|
|
end
|
2016-07-03 23:58:58 +00:00
|
|
|
end
|
2016-08-30 14:06:40 +00:00
|
|
|
|
|
|
|
describe '#update_ref!' do
|
|
|
|
it 'can create a ref' do
|
|
|
|
repository.update_ref!('refs/heads/foobar', 'refs/heads/master', Gitlab::Git::BLANK_SHA)
|
|
|
|
|
|
|
|
expect(repository.find_branch('foobar')).not_to be_nil
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'raises CommitError when the ref update fails' do
|
|
|
|
expect do
|
|
|
|
repository.update_ref!('refs/heads/master', 'refs/heads/master', Gitlab::Git::BLANK_SHA)
|
|
|
|
end.to raise_error(Repository::CommitError)
|
|
|
|
end
|
|
|
|
end
|
2014-09-29 13:40:13 +00:00
|
|
|
end
|