repository_spec.rb 78.8 KB
Newer Older
1 2
require 'spec_helper'

3
describe Repository do
4
  include RepoHelpers
5
  TestBlob = Struct.new(:path)
6

7
  let(:project) { create(:project, :repository) }
8
  let(:repository) { project.repository }
9
  let(:broken_repository) { create(:project, :broken_storage).repository }
10
  let(:user) { create(:user) }
11
  let(:git_user) { Gitlab::Git::User.from_gitlab(user) }
12

13
  let(:message) { 'Test message' }
14

Rubén Dávila's avatar
Rubén Dávila committed
15
  let(:merge_commit) do
16
    merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
17 18 19 20

    merge_commit_id = repository.merge(user,
                                       merge_request.diff_head_sha,
                                       merge_request,
21
                                       message)
22

23
    repository.commit(merge_commit_id)
24
  end
25

26 27
  let(:author_email) { 'user@example.org' }
  let(:author_name) { 'John Doe' }
28

29 30
  def expect_to_raise_storage_error
    expect { yield }.to raise_error do |exception|
31
      storage_exceptions = [Gitlab::Git::Storage::Inaccessible, Gitlab::Git::CommandError, GRPC::Unavailable]
32 33 34
      known_exception = storage_exceptions.select { |e| exception.is_a?(e) }

      expect(known_exception).not_to be_nil
35 36 37
    end
  end

38
  describe '#branch_names_contains' do
39 40 41
    shared_examples '#branch_names_contains' do
      set(:project) { create(:project, :repository) }
      let(:repository) { project.repository }
42

43
      subject { repository.branch_names_contains(sample_commit.id) }
44

45 46 47 48 49 50 51 52 53
      it { is_expected.to include('master') }
      it { is_expected.not_to include('feature') }
      it { is_expected.not_to include('fix') }

      describe 'when storage is broken', :broken_storage  do
        it 'should raise a storage error' do
          expect_to_raise_storage_error do
            broken_repository.branch_names_contains(sample_commit.id)
          end
54 55 56
        end
      end
    end
57 58 59 60 61 62 63 64

    context 'when gitaly is enabled' do
      it_behaves_like '#branch_names_contains'
    end

    context 'when gitaly is disabled', :skip_gitaly_mock do
      it_behaves_like '#branch_names_contains'
    end
65
  end
66

67
  describe '#tag_names_contains' do
68 69
    shared_examples '#tag_names_contains' do
      subject { repository.tag_names_contains(sample_commit.id) }
70

71 72 73 74 75 76 77 78 79 80 81
      it { is_expected.to include('v1.1.0') }
      it { is_expected.not_to include('v1.0.0') }
    end

    context 'when gitaly is enabled' do
      it_behaves_like '#tag_names_contains'
    end

    context 'when gitaly is enabled', :skip_gitaly_mock do
      it_behaves_like '#tag_names_contains'
    end
82 83
  end

84
  describe 'tags_sorted_by' do
haseeb's avatar
haseeb committed
85 86
    context 'name_desc' do
      subject { repository.tags_sorted_by('name_desc').map(&:name) }
87 88 89 90

      it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
    end

haseeb's avatar
haseeb committed
91 92 93 94 95 96
    context 'name_asc' do
      subject { repository.tags_sorted_by('name_asc').map(&:name) }

      it { is_expected.to eq(['v1.0.0', 'v1.1.0']) }
    end

97 98 99 100 101 102 103 104 105 106 107
    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)

108 109
          allow(tag_a).to receive(:dereferenced_target).and_return(double_first)
          allow(tag_b).to receive(:dereferenced_target).and_return(double_last)
110
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
111 112 113 114 115 116 117 118 119 120 121 122
        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)

123 124
          allow(tag_a).to receive(:dereferenced_target).and_return(double_last)
          allow(tag_b).to receive(:dereferenced_target).and_return(double_first)
125
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
126 127 128 129
        end

        it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
      end
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

      context 'annotated tag pointing to a blob' do
        let(:annotated_tag_name) { 'annotated-tag' }

        subject { repository.tags_sorted_by('updated_asc').map(&:name) }

        before do
          options = { message: 'test tag message\n',
                      tagger: { name: 'John Smith', email: 'john@gmail.com' } }
          repository.rugged.tags.create(annotated_tag_name, 'a48e4fc218069f68ef2e769dd8dfea3991362175', options)

          double_first = double(committed_date: Time.now - 1.second)
          double_last = double(committed_date: Time.now)

          allow(tag_a).to receive(:dereferenced_target).and_return(double_last)
          allow(tag_b).to receive(:dereferenced_target).and_return(double_first)
        end

        it { is_expected.to eq(['v1.1.0', 'v1.0.0', annotated_tag_name]) }

        after do
          repository.rugged.tags.delete(annotated_tag_name)
        end
      end
154 155 156
    end
  end

157
  describe '#ref_name_for_sha' do
158
    it 'returns the ref' do
159 160
      allow(repository.raw_repository).to receive(:ref_name_for_sha)
        .and_return('refs/environments/production/77')
161

162
      expect(repository.ref_name_for_sha('bla', '0' * 40)).to eq 'refs/environments/production/77'
163 164 165
    end
  end

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185
  describe '#ref_exists?' do
    context 'when ref exists' do
      it 'returns true' do
        expect(repository.ref_exists?('refs/heads/master')).to be true
      end
    end

    context 'when ref does not exist' do
      it 'returns false' do
        expect(repository.ref_exists?('refs/heads/non-existent')).to be false
      end
    end

    context 'when ref format is incorrect' do
      it 'returns false' do
        expect(repository.ref_exists?('refs/heads/invalid:master')).to be false
      end
    end
  end

186
  describe '#last_commit_for_path' do
187 188
    shared_examples 'getting last commit for path' do
      subject { repository.last_commit_for_path(sample_commit.id, '.gitignore').id }
189

190
      it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
191

192
      describe 'when storage is broken', :broken_storage  do
193 194 195 196 197 198
        it 'should raise a storage error' do
          expect_to_raise_storage_error do
            broken_repository.last_commit_id_for_path(sample_commit.id, '.gitignore')
          end
        end
      end
199 200 201 202 203
    end

    context 'when Gitaly feature last_commit_for_path is enabled' do
      it_behaves_like 'getting last commit for path'
    end
204

205
    context 'when Gitaly feature last_commit_for_path is disabled', :skip_gitaly_mock do
206 207
      it_behaves_like 'getting last commit for path'
    end
208
  end
209

Hiroyuki Sato's avatar
Hiroyuki Sato committed
210
  describe '#last_commit_id_for_path' do
211 212
    shared_examples 'getting last commit ID for path' do
      subject { repository.last_commit_id_for_path(sample_commit.id, '.gitignore') }
Hiroyuki Sato's avatar
Hiroyuki Sato committed
213

214 215 216 217 218 219 220 221 222 223 224
      it "returns last commit id for a given path" do
        is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8')
      end

      it "caches last commit id for a given path" do
        cache = repository.send(:cache)
        key = "last_commit_id_for_path:#{sample_commit.id}:#{Digest::SHA1.hexdigest('.gitignore')}"

        expect(cache).to receive(:fetch).with(key).and_return('c1acaa5')
        is_expected.to eq('c1acaa5')
      end
225

226
      describe 'when storage is broken', :broken_storage  do
227 228 229 230 231 232
        it 'should raise a storage error' do
          expect_to_raise_storage_error do
            broken_repository.last_commit_for_path(sample_commit.id, '.gitignore').id
          end
        end
      end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
233
    end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
234

235 236 237
    context 'when Gitaly feature last_commit_for_path is enabled' do
      it_behaves_like 'getting last commit ID for path'
    end
238

239
    context 'when Gitaly feature last_commit_for_path is disabled', :skip_gitaly_mock do
240
      it_behaves_like 'getting last commit ID for path'
Hiroyuki Sato's avatar
Hiroyuki Sato committed
241 242 243
    end
  end

244
  describe '#commits' do
Tiago Botelho's avatar
Tiago Botelho committed
245 246 247 248
    context 'when neither the all flag nor a ref are specified' do
      it 'returns every commit from default branch' do
        expect(repository.commits(limit: 60).size).to eq(37)
      end
249 250
    end

Tiago Botelho's avatar
Tiago Botelho committed
251 252 253 254
    context 'when ref is passed' do
      it 'returns every commit from the specified ref' do
        expect(repository.commits('master', limit: 60).size).to eq(37)
      end
255

Tiago Botelho's avatar
Tiago Botelho committed
256 257 258 259 260 261 262 263 264 265 266 267 268
      context 'when all' do
        it 'returns every commit from the repository' do
          expect(repository.commits('master', limit: 60, all: true).size).to eq(60)
        end
      end

      context 'with path' do
        it 'sets follow when it is a single path' do
          expect(Gitlab::Git::Commit).to receive(:where).with(a_hash_including(follow: true)).and_call_original.twice

          repository.commits('master', limit: 1, path: 'README.md')
          repository.commits('master', limit: 1, path: ['README.md'])
        end
269

Tiago Botelho's avatar
Tiago Botelho committed
270 271
        it 'does not set follow when it is multiple paths' do
          expect(Gitlab::Git::Commit).to receive(:where).with(a_hash_including(follow: false)).and_call_original
272

Tiago Botelho's avatar
Tiago Botelho committed
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
          repository.commits('master', limit: 1, path: ['README.md', 'CHANGELOG'])
        end
      end

      context 'without path' do
        it 'does not set follow' do
          expect(Gitlab::Git::Commit).to receive(:where).with(a_hash_including(follow: false)).and_call_original

          repository.commits('master', limit: 1)
        end
      end
    end

    context "when 'all' flag is set" do
      it 'returns every commit from the repository' do
        expect(repository.commits(all: true, limit: 60).size).to eq(60)
      end
290 291 292
    end
  end

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
  describe '#new_commits' do
    let(:new_refs) do
      double(:git_rev_list, new_refs: %w[
        c1acaa58bbcbc3eafe538cb8274ba387047b69f8
        5937ac0a7beb003549fc5fd26fc247adbce4a52e
      ])
    end

    it 'delegates to Gitlab::Git::RevList' do
      expect(Gitlab::Git::RevList).to receive(:new).with(
        repository.raw,
        newrev: 'aaaabbbbccccddddeeeeffffgggghhhhiiiijjjj').and_return(new_refs)

      commits = repository.new_commits('aaaabbbbccccddddeeeeffffgggghhhhiiiijjjj')

      expect(commits).to eq([
        repository.commit('c1acaa58bbcbc3eafe538cb8274ba387047b69f8'),
        repository.commit('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
      ])
    end
  end

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
  describe '#commits_by' do
    set(:project) { create(:project, :repository) }

    shared_examples 'batch commits fetching' do
      let(:oids) { TestEnv::BRANCH_SHA.values }

      subject { project.repository.commits_by(oids: oids) }

      it 'finds each commit' do
        expect(subject).not_to include(nil)
        expect(subject.size).to eq(oids.size)
      end

      it 'returns only Commit instances' do
        expect(subject).to all( be_a(Commit) )
      end

      context 'when some commits are not found ' do
        let(:oids) do
          ['deadbeef'] + TestEnv::BRANCH_SHA.values.first(10)
        end

        it 'returns only found commits' do
          expect(subject).not_to include(nil)
          expect(subject.size).to eq(10)
        end
      end

      context 'when no oids are passed' do
        let(:oids) { [] }

        it 'does not call #batch_by_oid' do
          expect(Gitlab::Git::Commit).not_to receive(:batch_by_oid)

          subject
        end
      end
    end

    context 'when Gitaly list_commits_by_oid is enabled' do
      it_behaves_like 'batch commits fetching'
    end

    context 'when Gitaly list_commits_by_oid is enabled', :disable_gitaly do
      it_behaves_like 'batch commits fetching'
    end
  end

363
  describe '#find_commits_by_message' do
364 365 366 367 368 369 370 371 372 373 374 375 376 377
    shared_examples 'finding commits by message' do
      it 'returns commits with messages containing a given string' do
        commit_ids = repository.find_commits_by_message('submodule').map(&:id)

        expect(commit_ids).to include(
          '5937ac0a7beb003549fc5fd26fc247adbce4a52e',
          '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9',
          'cfe32cf61b73a0d5e9f13e774abde7ff789b1660'
        )
        expect(commit_ids).not_to include('913c66a37b4a45b9769037c55c2d238bd0942d2e')
      end

      it 'is case insensitive' do
        commit_ids = repository.find_commits_by_message('SUBMODULE').map(&:id)
378

379 380
        expect(commit_ids).to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
      end
381 382
    end

383 384 385
    context 'when Gitaly commits_by_message feature is enabled' do
      it_behaves_like 'finding commits by message'
    end
386

387
    context 'when Gitaly commits_by_message feature is disabled', :skip_gitaly_mock do
388
      it_behaves_like 'finding commits by message'
389
    end
390

391
    describe 'when storage is broken', :broken_storage  do
392 393 394 395
      it 'should raise a storage error' do
        expect_to_raise_storage_error { broken_repository.find_commits_by_message('s') }
      end
    end
396 397
  end

398
  describe '#blob_at' do
399 400 401 402 403 404
    context 'blank sha' do
      subject { repository.blob_at(Gitlab::Git::BLANK_SHA, '.gitignore') }

      it { is_expected.to be_nil }
    end
  end
405

406
  describe '#merged_to_root_ref?' do
407
    context 'merged branch without ff' do
408
      subject { repository.merged_to_root_ref?('branch-merged') }
409 410 411

      it { is_expected.to be_truthy }
    end
412

413 414
    # If the HEAD was ff then it will be false
    context 'merged with ff' do
415 416 417 418
      subject { repository.merged_to_root_ref?('improve/awesome') }

      it { is_expected.to be_truthy }
    end
419

420 421 422 423 424
    context 'not merged branch' do
      subject { repository.merged_to_root_ref?('not-merged-branch') }

      it { is_expected.to be_falsey }
    end
425 426 427 428 429 430

    context 'default branch' do
      subject { repository.merged_to_root_ref?('master') }

      it { is_expected.to be_falsey }
    end
431 432
  end

433
  describe '#can_be_merged?' do
434 435 436
    shared_examples 'can be merged' do
      context 'mergeable branches' do
        subject { repository.can_be_merged?('0b4bc9a49b562e85de7cc9e834518ea6828729b9', 'master') }
437

438 439
        it { is_expected.to be_truthy }
      end
440

441
      context 'non-mergeable branches without conflict sides missing' do
442
        subject { repository.can_be_merged?('bb5206fee213d983da88c47f9cf4cc6caf9c66dc', 'feature') }
443

444 445
        it { is_expected.to be_falsey }
      end
446

447 448 449 450 451 452
      context 'non-mergeable branches with conflict sides missing' do
        subject { repository.can_be_merged?('conflict-missing-side', 'conflict-start') }

        it { is_expected.to be_falsey }
      end

453 454
      context 'non merged branch' do
        subject { repository.merged_to_root_ref?('fix') }
455

456 457 458 459 460 461 462 463
        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
464 465
    end

466 467 468
    context 'when Gitaly can_be_merged feature is enabled' do
      it_behaves_like 'can be merged'
    end
469

470 471
    context 'when Gitaly can_be_merged feature is disabled', :disable_gitaly do
      it_behaves_like 'can be merged'
472
    end
473 474
  end

475 476 477
  describe '#commit' do
    context 'when ref exists' do
      it 'returns commit object' do
478 479
        expect(repository.commit('master'))
          .to be_an_instance_of Commit
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503
      end
    end

    context 'when ref does not exist' do
      it 'returns nil' do
        expect(repository.commit('non-existent-ref')).to be_nil
      end
    end

    context 'when ref is not valid' do
      context 'when preceding tree element exists' do
        it 'returns nil' do
          expect(repository.commit('master:ref')).to be_nil
        end
      end

      context 'when preceding tree element does not exist' do
        it 'returns nil' do
          expect(repository.commit('non-existent:ref')).to be_nil
        end
      end
    end
  end

Douwe Maan's avatar
Douwe Maan committed
504
  describe "#create_dir" do
505 506
    it "commits a change that creates a new directory" do
      expect do
507
        repository.create_dir(user, 'newdir',
508
          message: 'Create newdir', branch_name: 'master')
509
      end.to change { repository.count_commits(ref: 'master') }.by(1)
510 511 512 513 514

      newdir = repository.tree('master', 'newdir')
      expect(newdir.path).to eq('newdir')
    end

515
    context "when committing to another project" do
516
      let(:forked_project) { create(:project, :repository) }
517 518 519

      it "creates a fork and commit to the forked project" do
        expect do
520
          repository.create_dir(user, 'newdir',
521
            message: 'Create newdir', branch_name: 'patch',
Lin Jen-Shin's avatar
Lin Jen-Shin committed
522
            start_branch_name: 'master', start_project: forked_project)
523
        end.to change { repository.count_commits(ref: 'master') }.by(0)
524 525 526 527 528 529 530 531 532

        expect(repository.branch_exists?('patch')).to be_truthy
        expect(forked_project.repository.branch_exists?('patch')).to be_falsy

        newdir = repository.tree('patch', 'newdir')
        expect(newdir.path).to eq('newdir')
      end
    end

533 534 535
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
536
          repository.create_dir(user, 'newdir',
537 538 539
            message: 'Add newdir',
            branch_name: 'master',
            author_email: author_email, author_name: author_name)
540
        end.to change { repository.count_commits(ref: 'master') }.by(1)
541 542 543 544 545 546 547 548 549

        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

550 551
  describe "#create_file" do
    it 'commits new file successfully' do
552
      expect do
553 554 555
        repository.create_file(user, 'NEWCHANGELOG', 'Changelog!',
                               message: 'Create changelog',
                               branch_name: 'master')
556
      end.to change { repository.count_commits(ref: 'master') }.by(1)
557

558
      blob = repository.blob_at('master', 'NEWCHANGELOG')
559

560
      expect(blob.data).to eq('Changelog!')
561
    end
562

563
    it 'creates new file and dir when file_path has a forward slash' do
564
      expect do
565 566
        repository.create_file(user, 'new_dir/new_file.txt', 'File!',
                               message: 'Create new_file with new_dir',
567
                               branch_name: 'master')
568
      end.to change { repository.count_commits(ref: 'master') }.by(1)
569

570 571
      expect(repository.tree('master', 'new_dir').path).to eq('new_dir')
      expect(repository.blob_at('master', 'new_dir/new_file.txt').data).to eq('File!')
572 573
    end

574
    it 'respects the autocrlf setting' do
575
      repository.create_file(user, 'hello.txt', "Hello,\r\nWorld",
576
                             message: 'Add hello world',
577
                             branch_name: 'master')
578 579 580 581 582 583

      blob = repository.blob_at('master', 'hello.txt')

      expect(blob.data).to eq("Hello,\nWorld")
    end

584 585 586
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
587
          repository.create_file(user, 'NEWREADME', 'README!',
588 589 590 591
                                 message: 'Add README',
                                 branch_name: 'master',
                                 author_email: author_email,
                                 author_name: author_name)
592
        end.to change { repository.count_commits(ref: 'master') }.by(1)
593 594 595 596 597 598 599

        last_commit = repository.commit

        expect(last_commit.author_email).to eq(author_email)
        expect(last_commit.author_name).to eq(author_name)
      end
    end
600 601
  end

602
  describe "#update_file" do
603 604 605 606 607
    it 'updates file successfully' do
      expect do
        repository.update_file(user, 'CHANGELOG', 'Changelog!',
                               message: 'Update changelog',
                               branch_name: 'master')
608
      end.to change { repository.count_commits(ref: 'master') }.by(1)
609 610 611 612 613 614

      blob = repository.blob_at('master', 'CHANGELOG')

      expect(blob.data).to eq('Changelog!')
    end

615
    it 'updates filename successfully' do
616 617
      expect do
        repository.update_file(user, 'NEWLICENSE', 'Copyright!',
618
                                     branch_name: 'master',
619
                                     previous_path: 'LICENSE',
620
                                     message: 'Changes filename')
621
      end.to change { repository.count_commits(ref: 'master') }.by(1)
622 623 624 625 626 627

      files = repository.ls_files('master')

      expect(files).not_to include('LICENSE')
      expect(files).to include('NEWLICENSE')
    end
628 629 630 631

    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
632 633 634 635 636 637
          repository.update_file(user, 'README', 'Updated README!',
                                 branch_name: 'master',
                                 previous_path: 'README',
                                 message: 'Update README',
                                 author_email: author_email,
                                 author_name: author_name)
638
        end.to change { repository.count_commits(ref: 'master') }.by(1)
639 640 641 642 643 644 645 646 647

        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

Douwe Maan's avatar
Douwe Maan committed
648
  describe "#delete_file" do
649 650
    it 'removes file successfully' do
      expect do
651
        repository.delete_file(user, 'README',
652
          message: 'Remove README', branch_name: 'master')
653
      end.to change { repository.count_commits(ref: 'master') }.by(1)
654 655 656 657 658 659 660

      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
        expect do
661
          repository.delete_file(user, 'README',
662 663
            message: 'Remove README', branch_name: 'master',
            author_email: author_email, author_name: author_name)
664
        end.to change { repository.count_commits(ref: 'master') }.by(1)
665 666 667 668 669 670 671 672 673

        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

674
  shared_examples "search_files_by_content" do
675
    let(:results) { repository.search_files_by_content('feature', 'master') }
676 677 678 679
    subject { results }

    it { is_expected.to be_an Array }

680
    it 'regex-escapes the query string' do
681
      results = repository.search_files_by_content("test\\", 'master')
682 683 684 685

      expect(results.first).not_to start_with('fatal:')
    end

686
    it 'properly handles an unmatched parenthesis' do
687
      results = repository.search_files_by_content("test(", 'master')
688 689 690 691

      expect(results.first).not_to start_with('fatal:')
    end

Valery Sizov's avatar
Valery Sizov committed
692
    it 'properly handles when query is not present' do
693
      results = repository.search_files_by_content('', 'master')
Valery Sizov's avatar
Valery Sizov committed
694 695 696 697 698

      expect(results).to match_array([])
    end

    it 'properly handles query when repo is empty' do
699
      repository = create(:project, :empty_repo).repository
700
      results = repository.search_files_by_content('test', 'master')
Valery Sizov's avatar
Valery Sizov committed
701 702 703 704

      expect(results).to match_array([])
    end

705
    describe 'when storage is broken', :broken_storage  do
706 707 708 709 710 711 712
      it 'should raise a storage error' do
        expect_to_raise_storage_error do
          broken_repository.search_files_by_content('feature', 'master')
        end
      end
    end

713 714 715 716
    describe 'result' do
      subject { results.first }

      it { is_expected.to be_an String }
717
      it { expect(subject.lines[2]).to eq("master:CHANGELOG\x00190\x00  - Feature: Replace teams with group membership\n") }
718 719
    end
  end
720

721
  shared_examples "search_files_by_name" do
722 723 724 725 726 727
    let(:results) { repository.search_files_by_name('files', 'master') }

    it 'returns result' do
      expect(results.first).to eq('files/html/500.html')
    end

Andrew McCallum's avatar
Andrew McCallum committed
728 729
    it 'ignores leading slashes' do
      results = repository.search_files_by_name('/files', 'master')
730

731 732 733
      expect(results.first).to eq('files/html/500.html')
    end

734
    it 'properly handles when query is only slashes' do
735
      results = repository.search_files_by_name('//', 'master')
736

737
      expect(results).to match_array([])
738 739
    end

740 741 742 743 744 745 746
    it 'properly handles when query is not present' do
      results = repository.search_files_by_name('', 'master')

      expect(results).to match_array([])
    end

    it 'properly handles query when repo is empty' do
747
      repository = create(:project, :empty_repo).repository
748 749 750 751 752

      results = repository.search_files_by_name('test', 'master')

      expect(results).to match_array([])
    end
753

754
    describe 'when storage is broken', :broken_storage  do
755 756 757 758 759 760
      it 'should raise a storage error' do
        expect_to_raise_storage_error { broken_repository.search_files_by_name('files', 'master') }
      end
    end
  end

761 762 763 764 765 766 767 768 769 770
  describe 'with gitaly enabled' do
    it_behaves_like 'search_files_by_content'
    it_behaves_like 'search_files_by_name'
  end

  describe 'with gitaly disabled', :disable_gitaly do
    it_behaves_like 'search_files_by_content'
    it_behaves_like 'search_files_by_name'
  end

771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
  describe '#async_remove_remote' do
    before do
      masterrev = repository.find_branch('master').dereferenced_target
      create_remote_branch('joe', 'remote_branch', masterrev)
    end

    context 'when worker is scheduled successfully' do
      before do
        masterrev = repository.find_branch('master').dereferenced_target
        create_remote_branch('remote_name', 'remote_branch', masterrev)

        allow(RepositoryRemoveRemoteWorker).to receive(:perform_async).and_return('1234')
      end

      it 'returns job_id' do
        expect(repository.async_remove_remote('joe')).to eq('1234')
      end
    end

    context 'when worker does not schedule successfully' do
      before do
        allow(RepositoryRemoveRemoteWorker).to receive(:perform_async).and_return(nil)
      end

      it 'returns nil' do
        expect(Rails.logger).to receive(:info).with("Remove remote job failed to create for #{project.id} with remote name joe.")

        expect(repository.async_remove_remote('joe')).to be_nil
      end
    end
  end

803
  describe '#fetch_ref' do
804
    let(:broken_repository) { create(:project, :broken_storage).repository }
805

806
    describe 'when storage is broken', :broken_storage  do
807
      it 'should raise a storage error' do
808 809 810
        expect_to_raise_storage_error do
          broken_repository.fetch_ref(broken_repository, source_ref: '1', target_ref: '2')
        end
811 812
      end
    end
813 814
  end

815
  describe '#create_ref' do
816
    it 'redirects the call to write_ref' do
817 818
      ref, ref_path = '1', '2'

819
      expect(repository.raw_repository).to receive(:write_ref).with(ref_path, ref)
820 821 822 823 824

      repository.create_ref(ref, ref_path)
    end
  end

825
  describe "#changelog", :use_clean_rails_memory_store_caching do
826 827 828
    it 'accepts changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changelog')])

829
      expect(repository.changelog.path).to eq('changelog')
830 831 832 833 834
    end

    it 'accepts news instead of changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('news')])

835
      expect(repository.changelog.path).to eq('news')
836 837 838 839 840
    end

    it 'accepts history instead of changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('history')])

841
      expect(repository.changelog.path).to eq('history')
842 843 844 845 846
    end

    it 'accepts changes instead of changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changes')])

847
      expect(repository.changelog.path).to eq('changes')
848 849 850 851 852
    end

    it 'is case-insensitive' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('CHANGELOG')])

853
      expect(repository.changelog.path).to eq('CHANGELOG')
854 855 856
    end
  end

857
  describe "#license_blob", :use_clean_rails_memory_store_caching do
858
    before do
859
      repository.delete_file(
860
        user, 'LICENSE', message: 'Remove LICENSE', branch_name: 'master')
861 862
    end

863
    it 'handles when HEAD points to non-existent ref' do
864
      repository.create_file(
865
        user, 'LICENSE', 'Copyright!',
866
        message: 'Add LICENSE', branch_name: 'master')
867

868
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
869 870 871 872

      expect(repository.license_blob).to be_nil
    end

873
    it 'looks in the root_ref only' do
874
      repository.delete_file(user, 'LICENSE',
875
        message: 'Remove LICENSE', branch_name: 'markdown')
876
      repository.create_file(user, 'LICENSE',
877
        Licensee::License.new('mit').content,
878
        message: 'Add LICENSE', branch_name: 'markdown')
879 880 881 882

      expect(repository.license_blob).to be_nil
    end

883
    it 'detects license file with no recognizable open-source license content' do
884 885
      repository.create_file(user, 'LICENSE', 'Copyright!',
        message: 'Add LICENSE', branch_name: 'master')
886

887
      expect(repository.license_blob.path).to eq('LICENSE')
888 889
    end

890 891
    %w[LICENSE LICENCE LiCensE LICENSE.md LICENSE.foo COPYING COPYING.md].each do |filename|
      it "detects '#{filename}'" do
892
        repository.create_file(user, filename,
893
          Licensee::License.new('mit').content,
894
          message: "Add #{filename}", branch_name: 'master')
895

896 897
        expect(repository.license_blob.name).to eq(filename)
      end
898 899 900
    end
  end

901
  describe '#license_key', :use_clean_rails_memory_store_caching do
902
    before do
903
      repository.delete_file(user, 'LICENSE',
904
        message: 'Remove LICENSE', branch_name: 'master')
905
    end
906

907
    it 'returns nil when no license is detected' do
908 909 910
      expect(repository.license_key).to be_nil
    end

911 912 913
    it 'returns nil when the repository does not exist' do
      expect(repository).to receive(:exists?).and_return(false)

914 915 916
      expect(repository.license_key).to be_nil
    end

917
    it 'returns nil when the content is not recognizable' do
918
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
919
        message: 'Add LICENSE', branch_name: 'master')
920 921

      expect(repository.license_key).to be_nil
922
    end
923

924 925 926 927 928 929
    it 'returns nil when the commit SHA does not exist' do
      allow(repository.head_commit).to receive(:sha).and_return('1' * 40)

      expect(repository.license_key).to be_nil
    end

930
    it 'returns nil when master does not exist' do
931 932
      repository.rm_branch(user, 'master')

933
      expect(repository.license_key).to be_nil
934 935
    end

936
    it 'returns the license key' do
937
      repository.create_file(user, 'LICENSE',
938
        Licensee::License.new('mit').content,
939
        message: 'Add LICENSE', branch_name: 'master')
940

941
      expect(repository.license_key).to eq('mit')
942
    end
943
  end
944

945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
  describe '#license' do
    before do
      repository.delete_file(user, 'LICENSE',
        message: 'Remove LICENSE', branch_name: 'master')
    end

    it 'returns nil when no license is detected' do
      expect(repository.license).to be_nil
    end

    it 'returns nil when the repository does not exist' do
      expect(repository).to receive(:exists?).and_return(false)

      expect(repository.license).to be_nil
    end

    it 'returns nil when the content is not recognizable' do
962
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
963 964 965 966 967 968 969 970 971 972 973 974 975 976 977
        message: 'Add LICENSE', branch_name: 'master')

      expect(repository.license).to be_nil
    end

    it 'returns the license' do
      license = Licensee::License.new('mit')
      repository.create_file(user, 'LICENSE',
        license.content,
        message: 'Add LICENSE', branch_name: 'master')

      expect(repository.license).to eq(license)
    end
  end

978
  describe "#gitlab_ci_yml", :use_clean_rails_memory_store_caching do
979 980 981 982
    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)

983
      expect(repository.gitlab_ci_yml.path).to eq('.gitlab-ci.yml')
984 985 986 987 988 989 990 991
    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
992
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
993 994 995 996
      expect(repository.gitlab_ci_yml).to be_nil
    end
  end

997
  describe '#add_branch' do
998 999
    let(:branch_name) { 'new_feature' }
    let(:target) { 'master' }
1000

1001
    subject { repository.add_branch(user, branch_name, target) }
1002

1003 1004 1005 1006
    it "calls Gitaly's OperationService" do
      expect_any_instance_of(Gitlab::GitalyClient::OperationService)
        .to receive(:user_create_branch).with(branch_name, user, target)
        .and_return(nil)
1007

1008
      subject
1009 1010
    end

1011 1012 1013 1014
    it 'creates_the_branch' do
      expect(subject.name).to eq(branch_name)
      expect(repository.find_branch(branch_name)).not_to be_nil
    end
1015

1016 1017
    context 'with a non-existing target' do
      let(:target) { 'fake-target' }
1018

1019 1020 1021
      it "returns false and doesn't create the branch" do
        expect(subject).to be(false)
        expect(repository.find_branch(branch_name)).to be_nil
1022 1023 1024 1025
      end
    end
  end

1026
  describe '#find_branch' do
1027 1028 1029
    context 'fresh_repo is true' do
      it 'delegates the call to raw_repository' do
        expect(repository.raw_repository).to receive(:find_branch).with('master', true)
1030

1031
        repository.find_branch('master', fresh_repo: true)
1032 1033 1034
      end
    end

1035 1036 1037
    context 'fresh_repo is false' do
      it 'delegates the call to raw_repository' do
        expect(repository.raw_repository).to receive(:find_branch).with('master', false)
1038

1039
        repository.find_branch('master', fresh_repo: false)
1040 1041 1042 1043
      end
    end
  end

1044
  describe '#update_branch_with_hooks' do
1045
    let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature
1046
    let(:new_rev) { 'a74ae73c1ccde9b974a70e82b901588071dc142a' } # commit whose parent is old_rev
1047 1048 1049
    let(:updating_ref) { 'refs/heads/feature' }
    let(:target_project) { project }
    let(:target_repository) { target_project.repository }
1050

1051
    context 'when pre hooks were successful' do
1052
      before do
1053 1054
        service = Gitlab::Git::HooksService.new
        expect(Gitlab::Git::HooksService).to receive(:new).and_return(service)
1055
        expect(service).to receive(:execute)
1056
          .with(git_user, target_repository.raw_repository, old_rev, new_rev, updating_ref)
1057
          .and_yield(service).and_return(true)
1058
      end
1059

1060
      it 'runs without errors' do
1061
        expect do
1062
          Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch('feature') do
1063 1064
            new_rev
          end
1065 1066
        end.not_to raise_error
      end
1067

1068
      it 'ensures the autocrlf Git option is set to :input' do
1069
        service = Gitlab::Git::OperationService.new(git_user, repository.raw_repository)
1070 1071

        expect(service).to receive(:update_autocrlf_option)
1072

1073
        service.with_branch('feature') { new_rev }
1074
      end
1075 1076 1077

      context "when the branch wasn't empty" do
        it 'updates the head' do
1078
          expect(repository.find_branch('feature').dereferenced_target.id).to eq(old_rev)
1079

1080
          Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch('feature') do
1081 1082 1083
            new_rev
          end

1084
          expect(repository.find_branch('feature').dereferenced_target.id).to eq(new_rev)
1085 1086
        end
      end
1087 1088 1089 1090 1091 1092 1093 1094

      context 'when target project does not have the commit' do
        let(:target_project) { create(:project, :empty_repo) }
        let(:old_rev) { Gitlab::Git::BLANK_SHA }
        let(:new_rev) { project.commit('feature').sha }
        let(:updating_ref) { 'refs/heads/master' }

        it 'fetch_ref and create the branch' do
1095
          expect(target_project.repository.raw_repository).to receive(:fetch_ref)
1096 1097
            .and_call_original

1098
          Gitlab::Git::OperationService.new(git_user, target_repository.raw_repository)
1099 1100
            .with_branch(
              'master',
1101
              start_repository: project.repository.raw_repository,
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
              start_branch_name: 'feature') { new_rev }

          expect(target_repository.branch_names).to contain_exactly('master')
        end
      end

      context 'when target project already has the commit' do
        let(:target_project) { create(:project, :repository) }

        it 'does not fetch_ref and just pass the commit' do
          expect(target_repository).not_to receive(:fetch_ref)

1114
          Gitlab::Git::OperationService.new(git_user, target_repository.raw_repository)
1115
            .with_branch('feature', start_repository: project.repository.raw_repository) { new_rev }
1116 1117
        end
      end
1118 1119
    end

1120 1121 1122 1123
    context 'when temporary ref failed to be created from other project' do
      let(:target_project) { create(:project, :empty_repo) }

      before do
1124
        expect(target_project.repository.raw_repository).to receive(:run_git)
1125 1126 1127 1128 1129 1130 1131 1132
      end

      it 'raises Rugged::ReferenceError' do
        raise_reference_error = raise_error(Rugged::ReferenceError) do |err|
          expect(err.cause).to be_nil
        end

        expect do
1133
          Gitlab::Git::OperationService.new(git_user, target_project.repository.raw_repository)
1134
            .with_branch('feature',
1135
                         start_repository: project.repository.raw_repository,
1136 1137 1138 1139 1140
                         &:itself)
        end.to raise_reference_error
      end
    end

1141
    context 'when the update adds more than one commit' do
1142
      let(:old_rev) { '33f3729a45c02fc67d00adb1b8bca394b0e761d9' }
1143

1144
      it 'runs without errors' do
1145
        # old_rev is an ancestor of new_rev
1146
        expect(repository.merge_base(old_rev, new_rev)).to eq(old_rev)
1147 1148 1149 1150

        # old_rev is not a direct ancestor (parent) of new_rev
        expect(repository.rugged.lookup(new_rev).parent_ids).not_to include(old_rev)

1151 1152 1153
        branch = 'feature-ff-target'
        repository.add_branch(user, branch, old_rev)

1154
        expect do
1155
          Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch(branch) do
1156 1157 1158
            new_rev
          end
        end.not_to raise_error
1159 1160 1161 1162
      end
    end

    context 'when the update would remove commits from the target branch' do
1163 1164
      let(:branch) { 'master' }
      let(:old_rev) { repository.find_branch(branch).dereferenced_target.sha }
1165

1166
      it 'raises an exception' do
1167
        # The 'master' branch is NOT an ancestor of new_rev.
1168
        expect(repository.merge_base(old_rev, new_rev)).not_to eq(old_rev)
1169 1170 1171 1172

        # 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
1173
          Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch(branch) do
1174 1175
            new_rev
          end
1176
        end.to raise_error(Gitlab::Git::CommitError)
1177 1178 1179
      end
    end

1180
    context 'when pre hooks failed' do
1181
      it 'gets an error' do
1182
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
1183 1184

        expect do
1185
          Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch('feature') do
1186 1187
            new_rev
          end
1188
        end.to raise_error(Gitlab::Git::HooksService::PreReceiveError)
1189 1190
      end
    end
1191 1192 1193 1194 1195 1196

    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, ''])
      end

1197 1198
      subject do
        Gitlab::Git::OperationService.new(git_user, repository.raw_repository).with_branch('new-feature') do
Jacob Vosmaer's avatar
Jacob Vosmaer committed
1199
          new_rev
1200
        end
1201
      end
1202 1203 1204 1205 1206

      it 'returns branch_created as true' do
        expect(subject).not_to be_repo_created
        expect(subject).to     be_branch_created
      end
1207 1208 1209 1210 1211 1212 1213 1214
    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
1215
        empty_repository = create(:project, :empty_repo).repository
1216 1217 1218 1219 1220 1221

        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)

1222
        empty_repository.create_file(user, 'CHANGELOG', 'Changelog!',
1223
                                     message: 'Updates file content',
1224
                                     branch_name: 'master')
1225 1226
      end
    end
1227
  end
1228

1229
  describe '#exists?' do
1230
    it 'returns true when a repository exists' do
1231
      expect(repository.exists?).to be(true)
1232 1233
    end

1234
    it 'returns false if no full path can be constructed' do
1235
      allow(repository).to receive(:full_path).and_return(nil)
1236

1237
      expect(repository.exists?).to be(false)
1238
    end
1239

1240
    context 'with broken storage', :broken_storage do
1241 1242 1243 1244
      it 'should raise a storage error' do
        expect_to_raise_storage_error { broken_repository.exists? }
      end
    end
1245
  end
1246

1247
  describe '#has_visible_content?' do
1248 1249 1250 1251 1252 1253 1254
    before do
      # If raw_repository.has_visible_content? gets called more than once then
      # caching is broken. We don't want that.
      expect(repository.raw_repository).to receive(:has_visible_content?)
        .once
        .and_return(result)
    end
1255

1256 1257
    context 'when true' do
      let(:result) { true }
1258

1259 1260 1261 1262 1263
      it 'returns true and caches it' do
        expect(repository.has_visible_content?).to eq(true)
        # Second call hits the cache
        expect(repository.has_visible_content?).to eq(true)
      end
1264 1265
    end

1266 1267
    context 'when false' do
      let(:result) { false }
1268

1269 1270 1271 1272
      it 'returns false and caches it' do
        expect(repository.has_visible_content?).to eq(false)
        # Second call hits the cache
        expect(repository.has_visible_content?).to eq(false)
1273 1274 1275 1276
      end
    end
  end

1277 1278 1279 1280 1281 1282 1283 1284 1285
  describe '#branch_exists?' do
    it 'uses branch_names' do
      allow(repository).to receive(:branch_names).and_return(['foobar'])

      expect(repository.branch_exists?('foobar')).to eq(true)
      expect(repository.branch_exists?('master')).to eq(false)
    end
  end

1286 1287 1288 1289 1290 1291 1292 1293 1294
  describe '#tag_exists?' do
    it 'uses tag_names' do
      allow(repository).to receive(:tag_names).and_return(['foobar'])

      expect(repository.tag_exists?('foobar')).to eq(true)
      expect(repository.tag_exists?('master')).to eq(false)
    end
  end

1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
  describe '#branch_names', :use_clean_rails_memory_store_caching do
    let(:fake_branch_names) { ['foobar'] }

    it 'gets cached across Repository instances' do
      allow(repository.raw_repository).to receive(:branch_names).once.and_return(fake_branch_names)

      expect(repository.branch_names).to eq(fake_branch_names)

      fresh_repository = Project.find(project.id).repository
      expect(fresh_repository.object_id).not_to eq(repository.object_id)

      expect(fresh_repository.raw_repository).not_to receive(:branch_names)
      expect(fresh_repository.branch_names).to eq(fake_branch_names)
    end
  end

1311 1312 1313 1314 1315 1316 1317
  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
1318
        Gitlab::Git::OperationService.new(nil, repository.raw_repository).send(:update_autocrlf_option)
1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329

        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
1330 1331
        expect(repository.raw_repository).not_to receive(:autocrlf=)
          .with(:input)
1332

1333
        Gitlab::Git::OperationService.new(nil, repository.raw_repository).send(:update_autocrlf_option)
1334 1335 1336 1337
      end
    end
  end

1338 1339 1340 1341
  describe '#empty?' do
    let(:empty_repository) { create(:project_empty_repo).repository }

    it 'returns true for an empty repository' do
1342
      expect(empty_repository).to be_empty
1343 1344 1345
    end

    it 'returns false for a non-empty repository' do
1346
      expect(repository).not_to be_empty
1347 1348 1349
    end

    it 'caches the output' do
1350
      expect(repository.raw_repository).to receive(:has_visible_content?).once
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362

      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
1363 1364 1365
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('master')
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375

      repository.root_ref
      repository.root_ref
    end
  end

  describe '#expire_root_ref_cache' do
    it 'expires the root reference cache' do
      repository.root_ref

1376 1377 1378
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('foo')
1379 1380 1381 1382 1383 1384 1385

      repository.expire_root_ref_cache

      expect(repository.root_ref).to eq('foo')
    end
  end

1386
  describe '#expire_branch_cache' do
1387 1388 1389 1390 1391
    # 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
1392 1393 1394
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1395 1396 1397 1398 1399

      repository.expire_branch_cache
    end

    it 'expires the cache for all branches when the root branch is given' do
1400 1401 1402
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1403 1404 1405 1406 1407

      repository.expire_branch_cache(repository.root_ref)
    end

    it 'expires the cache for a specific branch' do
1408
      expect(cache).to receive(:expire).twice
1409 1410 1411 1412

      repository.expire_branch_cache('foo')
    end
  end
1413

1414 1415 1416
  describe '#expire_emptiness_caches' do
    let(:cache) { repository.send(:cache) }

1417 1418 1419
    it 'expires the caches for an empty repository' do
      allow(repository).to receive(:empty?).and_return(true)

1420
      expect(cache).to receive(:expire).with(:has_visible_content?)
1421 1422 1423

      repository.expire_emptiness_caches
    end
1424 1425 1426 1427

    it 'does not expire the cache for a non-empty repository' do
      allow(repository).to receive(:empty?).and_return(false)

1428
      expect(cache).not_to receive(:expire).with(:has_visible_content?)
1429 1430 1431

      repository.expire_emptiness_caches
    end
1432 1433 1434 1435 1436 1437

    it 'expires the memoized repository cache' do
      allow(repository.raw_repository).to receive(:expire_has_local_branches_cache).and_call_original

      repository.expire_emptiness_caches
    end
1438 1439
  end

1440
  describe 'skip_merges option' do
1441
    subject { repository.commits(Gitlab::Git::BRANCH_REF_PREFIX + "'test'", limit: 100, skip_merges: true).map { |k| k.id } }
1442 1443 1444

    it { is_expected.not_to include('e56497bb5f03a90a51293fc6d516788730953899') }
  end
1445 1446

  describe '#merge' do
1447 1448
    let(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project) }

1449
    let(:message) { 'Test \r\n\r\n message' }
1450

1451 1452 1453 1454 1455 1456 1457 1458
    shared_examples '#merge' do
      it 'merges the code and returns the commit id' do
        expect(merge_commit).to be_present
        expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
      end

      it 'sets the `in_progress_merge_commit_sha` flag for the given merge request' do
        merge_commit_id = merge(repository, user, merge_request, message)
1459

1460 1461 1462 1463 1464
        expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
      end

      it 'removes carriage returns from commit message' do
        merge_commit_id = merge(repository, user, merge_request, message)
1465

1466 1467
        expect(repository.commit(merge_commit_id).message).to eq(message.delete("\r"))
      end
1468
    end
1469

1470 1471 1472
    context 'with gitaly' do
      it_behaves_like '#merge'
    end
1473

1474 1475
    context 'without gitaly', :skip_gitaly_mock do
      it_behaves_like '#merge'
1476 1477
    end

1478 1479
    def merge(repository, user, merge_request, message)
      repository.merge(user, merge_request.diff_head_sha, merge_request, message)
1480
    end
1481 1482
  end

1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
  describe '#ff_merge' do
    before do
      repository.add_branch(user, 'ff-target', 'feature~5')
    end

    it 'merges the code and return the commit id' do
      merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'ff-target', source_project: project)
      merge_commit_id = repository.ff_merge(user,
                                            merge_request.diff_head_sha,
                                            merge_request.target_branch,
                                            merge_request: merge_request)
      merge_commit = repository.commit(merge_commit_id)

      expect(merge_commit).to be_present
      expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
    end

    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: 'ff-target', source_project: project)
      merge_commit_id = repository.ff_merge(user,
                                            merge_request.diff_head_sha,
                                            merge_request.target_branch,
                                            merge_request: merge_request)

      expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
    end
  end

1511
  describe '#revert' do
1512 1513 1514 1515 1516 1517 1518 1519 1520
    shared_examples 'reverting a commit' do
      let(:new_image_commit) { repository.commit('33f3729a45c02fc67d00adb1b8bca394b0e761d9') }
      let(:update_image_commit) { repository.commit('2f63565e7aac07bcdadb654e253078b727143ec4') }
      let(:message) { 'revert message' }

      context 'when there is a conflict' do
        it 'raises an error' do
          expect { repository.revert(user, new_image_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
        end
1521 1522
      end

1523 1524 1525
      context 'when commit was already reverted' do
        it 'raises an error' do
          repository.revert(user, update_image_commit, 'master', message)
1526

1527 1528
          expect { repository.revert(user, update_image_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
        end
1529 1530
      end

1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544
      context 'when commit can be reverted' do
        it 'reverts the changes' do
          expect(repository.revert(user, update_image_commit, 'master', message)).to be_truthy
        end
      end

      context 'reverting a merge commit' do
        it 'reverts the changes' do
          merge_commit
          expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).to be_present

          repository.revert(user, merge_commit, 'master', message)
          expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).not_to be_present
        end
1545 1546 1547
      end
    end

1548 1549 1550
    context 'when Gitaly revert feature is enabled' do
      it_behaves_like 'reverting a commit'
    end
1551

1552 1553
    context 'when Gitaly revert feature is disabled', :disable_gitaly do
      it_behaves_like 'reverting a commit'
1554 1555
    end
  end
1556

1557
  describe '#cherry_pick' do
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
    shared_examples 'cherry-picking a commit' do
      let(:conflict_commit) { repository.commit('c642fe9b8b9f28f9225d7ea953fe14e74748d53b') }
      let(:pickable_commit) { repository.commit('7d3b0f7cff5f37573aea97cebfd5692ea1689924') }
      let(:pickable_merge) { repository.commit('e56497bb5f03a90a51293fc6d516788730953899') }
      let(:message) { 'cherry-pick message' }

      context 'when there is a conflict' do
        it 'raises an error' do
          expect { repository.cherry_pick(user, conflict_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
        end
1568 1569
      end

1570 1571 1572
      context 'when commit was already cherry-picked' do
        it 'raises an error' do
          repository.cherry_pick(user, pickable_commit, 'master', message)
1573

1574 1575
          expect { repository.cherry_pick(user, pickable_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
        end
1576 1577
      end

1578 1579 1580 1581
      context 'when commit can be cherry-picked' do
        it 'cherry-picks the changes' do
          expect(repository.cherry_pick(user, pickable_commit, 'master', message)).to be_truthy
        end
1582 1583
      end

1584 1585 1586
      context 'cherry-picking a merge commit' do
        it 'cherry-picks the changes' do
          expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).to be_nil
1587

1588 1589
          cherry_pick_commit_sha = repository.cherry_pick(user, pickable_merge, 'improve/awesome', message)
          cherry_pick_commit_message = project.commit(cherry_pick_commit_sha).message
1590

1591 1592 1593
          expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).not_to be_nil
          expect(cherry_pick_commit_message).to eq(message)
        end
1594 1595
      end
    end
1596 1597 1598 1599 1600 1601 1602 1603

    context 'when Gitaly cherry_pick feature is enabled' do
      it_behaves_like 'cherry-picking a commit'
    end

    context 'when Gitaly cherry_pick feature is disabled', :disable_gitaly do
      it_behaves_like 'cherry-picking a commit'
    end
1604 1605
  end

1606 1607 1608 1609 1610 1611 1612
  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
1613
        expect(repository).not_to receive(:expire_cache)
1614 1615 1616 1617

        repository.before_delete
      end

1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629
      it 'flushes the tags cache' do
        expect(repository).to receive(:expire_tags_cache)

        repository.before_delete
      end

      it 'flushes the branches cache' do
        expect(repository).to receive(:expire_branches_cache)

        repository.before_delete
      end

1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640
      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
1641 1642

      it 'flushes the exists cache' do
1643
        expect(repository).to receive(:expire_exists_cache).twice
1644 1645 1646

        repository.before_delete
      end
1647 1648 1649 1650 1651 1652 1653
    end

    describe 'when a repository exists' do
      before do
        allow(repository).to receive(:exists?).and_return(true)
      end

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
      it 'flushes the tags cache' do
        expect(repository).to receive(:expire_tags_cache)

        repository.before_delete
      end

      it 'flushes the branches cache' do
        expect(repository).to receive(:expire_branches_cache)

        repository.before_delete
      end

1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
      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

1694 1695 1696 1697 1698 1699 1700 1701 1702 1703
  describe '#after_change_head' do
    it 'flushes the readme cache' do
      expect(repository).to receive(:expire_method_caches).with([
        :readme,
        :changelog,
        :license,
        :contributing,
        :gitignore,
        :koding,
        :gitlab_ci,
1704 1705
        :avatar,
        :issue_template,
1706 1707
        :merge_request_template,
        :xcode_config
1708 1709 1710 1711 1712 1713
      ])

      repository.after_change_head
    end
  end

1714
  describe '#before_push_tag' do
1715
    it 'flushes the cache' do
1716 1717 1718
      expect(repository).to receive(:expire_statistics_caches)
      expect(repository).to receive(:expire_emptiness_caches)
      expect(repository).to receive(:expire_tags_cache)
1719

1720
      repository.before_push_tag
1721 1722 1723 1724
    end
  end

  describe '#after_import' do
1725 1726
    it 'flushes and builds the cache' do
      expect(repository).to receive(:expire_content_cache)
1727 1728 1729

      repository.after_import
    end
1730 1731 1732
  end

  describe '#after_push_commit' do
1733
    it 'expires statistics caches' do
1734 1735
      expect(repository).to receive(:expire_statistics_caches)
        .and_call_original
1736

1737 1738 1739
      expect(repository).to receive(:expire_branch_cache)
        .with('master')
        .and_call_original
1740

1741
      repository.after_push_commit('master')
1742 1743 1744 1745
    end
  end

  describe '#after_create_branch' do
1746
    it 'expires the branch caches' do
1747
      expect(repository).to receive(:expire_branches_cache)
1748 1749 1750 1751 1752 1753

      repository.after_create_branch
    end
  end

  describe '#after_remove_branch' do
1754
    it 'expires the branch caches' do
1755
      expect(repository).to receive(:expire_branches_cache)
1756 1757 1758 1759

      repository.after_remove_branch
    end
  end
1760

1761 1762 1763 1764 1765 1766
  describe '#after_create' do
    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

      repository.after_create
    end
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778

    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
1779 1780
  end

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
  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

1791 1792
  describe '#before_remove_tag' do
    it 'flushes the tag cache' do
1793 1794
      expect(repository).to receive(:expire_tags_cache).and_call_original
      expect(repository).to receive(:expire_statistics_caches).and_call_original
1795 1796 1797 1798 1799 1800 1801

      repository.before_remove_tag
    end
  end

  describe '#branch_count' do
    it 'returns the number of branches' do
Douwe Maan's avatar
Douwe Maan committed
1802
      expect(repository.branch_count).to be_an(Integer)
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1803 1804

      # NOTE: Until rugged goes away, make sure rugged and gitaly are in sync
1805
      rugged_count = repository.raw_repository.rugged.branches.count
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1806

1807
      expect(repository.branch_count).to eq(rugged_count)
1808 1809 1810 1811 1812
    end
  end

  describe '#tag_count' do
    it 'returns the number of tags' do
Douwe Maan's avatar
Douwe Maan committed
1813
      expect(repository.tag_count).to be_an(Integer)
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1814

1815 1816
      # NOTE: Until rugged goes away, make sure rugged and gitaly are in sync
      rugged_count = repository.raw_repository.rugged.tags.count
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1817

1818
      expect(repository.tag_count).to eq(rugged_count)
1819 1820 1821
    end
  end

1822
  describe '#expire_branches_cache' do
1823
    it 'expires the cache' do
1824
      expect(repository).to receive(:expire_method_caches)
1825
        .with(%i(branch_names branch_count has_visible_content?))
1826
        .and_call_original
1827

1828
      repository.expire_branches_cache
1829 1830 1831
    end
  end

1832
  describe '#expire_tags_cache' do
1833
    it 'expires the cache' do
1834 1835 1836
      expect(repository).to receive(:expire_method_caches)
        .with(%i(tag_names tag_count))
        .and_call_original
1837

1838
      repository.expire_tags_cache
1839 1840
    end
  end
1841

1842
  describe '#add_tag' do
1843
    let(:user) { build_stubbed(:user) }
1844

1845 1846 1847 1848
    shared_examples 'adding tag' do
      context 'with a valid target' do
        it 'creates the tag' do
          repository.add_tag(user, '8.5', 'master', 'foo')
1849

1850 1851 1852 1853 1854
          tag = repository.find_tag('8.5')
          expect(tag).to be_present
          expect(tag.message).to eq('foo')
          expect(tag.dereferenced_target.id).to eq(repository.commit('master').id)
        end
1855

1856 1857
        it 'returns a Gitlab::Git::Tag object' do
          tag = repository.add_tag(user, '8.5', 'master', 'foo')
1858

1859 1860 1861
          expect(tag).to be_a(Gitlab::Git::Tag)
        end
      end
1862

1863 1864 1865 1866
      context 'with an invalid target' do
        it 'returns false' do
          expect(repository.add_tag(user, '8.5', 'bar', 'foo')).to be false
        end
1867
      end
1868
    end
1869

1870 1871 1872
    context 'when Gitaly operation_user_add_tag feature is enabled' do
      it_behaves_like 'adding tag'
    end
1873

1874
    context 'when Gitaly operation_user_add_tag feature is disabled', :disable_gitaly do
1875 1876 1877
      it_behaves_like 'adding tag'

      it 'passes commit SHA to pre-receive and update hooks and tag SHA to post-receive hook' do
1878 1879 1880
        pre_receive_hook = Gitlab::Git::Hook.new('pre-receive', project)
        update_hook = Gitlab::Git::Hook.new('update', project)
        post_receive_hook = Gitlab::Git::Hook.new('post-receive', project)
1881

1882 1883
        allow(Gitlab::Git::Hook).to receive(:new)
          .and_return(pre_receive_hook, update_hook, post_receive_hook)
1884 1885 1886 1887 1888 1889 1890 1891 1892 1893

        allow(pre_receive_hook).to receive(:trigger).and_call_original
        allow(update_hook).to receive(:trigger).and_call_original
        allow(post_receive_hook).to receive(:trigger).and_call_original

        tag = repository.add_tag(user, '8.5', 'master', 'foo')

        commit_sha = repository.commit('master').id
        tag_sha = tag.target

1894
        expect(pre_receive_hook).to have_received(:trigger)
1895
          .with(anything, anything, anything, commit_sha, anything)
1896
        expect(update_hook).to have_received(:trigger)
1897
          .with(anything, anything, anything, commit_sha, anything)
1898
        expect(post_receive_hook).to have_received(:trigger)
1899
          .with(anything, anything, anything, tag_sha, anything)
1900
      end
1901 1902 1903
    end
  end

1904
  describe '#rm_branch' do
1905 1906 1907 1908 1909 1910 1911 1912
    shared_examples "user deleting a branch" do
      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
1913

1914 1915
    context 'with gitaly enabled' do
      it_behaves_like "user deleting a branch"
1916

1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
      context 'when pre hooks failed' do
        before do
          allow_any_instance_of(Gitlab::GitalyClient::OperationService)
            .to receive(:user_delete_branch).and_raise(Gitlab::Git::HooksService::PreReceiveError)
        end

        it 'gets an error and does not delete the branch' do
          expect do
            repository.rm_branch(user, 'feature')
          end.to raise_error(Gitlab::Git::HooksService::PreReceiveError)

          expect(repository.find_branch('feature')).not_to be_nil
        end
      end
    end

1933
    context 'with gitaly disabled', :disable_gitaly do
1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973
      it_behaves_like "user deleting a branch"

      let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature
      let(:blank_sha) { '0000000000000000000000000000000000000000' }

      context 'when pre hooks were successful' do
        it 'runs without errors' do
          expect_any_instance_of(Gitlab::Git::HooksService).to receive(:execute)
            .with(git_user, repository.raw_repository, old_rev, blank_sha, 'refs/heads/feature')

          expect { repository.rm_branch(user, 'feature') }.not_to raise_error
        end

        it 'deletes the branch' do
          allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])

          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
        it 'gets an error' do
          allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])

          expect do
            repository.rm_branch(user, 'feature')
          end.to raise_error(Gitlab::Git::HooksService::PreReceiveError)
        end

        it 'does not delete the branch' do
          allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])

          expect do
            repository.rm_branch(user, 'feature')
          end.to raise_error(Gitlab::Git::HooksService::PreReceiveError)
          expect(repository.find_branch('feature')).not_to be_nil
        end
      end
1974 1975
    end
  end
1976 1977

  describe '#rm_tag' do
1978 1979 1980
    shared_examples 'removing tag' do
      it 'removes a tag' do
        expect(repository).to receive(:before_remove_tag)
1981

1982
        repository.rm_tag(build_stubbed(:user), 'v1.1.0')
Lin Jen-Shin's avatar
Lin Jen-Shin committed
1983

1984 1985 1986 1987 1988 1989 1990 1991
        expect(repository.find_tag('v1.1.0')).to be_nil
      end
    end

    context 'when Gitaly operation_user_delete_tag feature is enabled' do
      it_behaves_like 'removing tag'
    end

1992
    context 'when Gitaly operation_user_delete_tag feature is disabled', :skip_gitaly_mock do
1993
      it_behaves_like 'removing tag'
1994 1995
    end
  end
1996 1997

  describe '#avatar' do
1998
    it 'returns nil if repo does not exist' do
1999
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
2000 2001 2002 2003

      expect(repository.avatar).to eq(nil)
    end

2004
    it 'returns the first avatar file found in the repository' do
2005 2006 2007
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .and_return(double(:tree, path: 'logo.png'))
2008 2009 2010 2011 2012

      expect(repository.avatar).to eq('logo.png')
    end

    it 'caches the output' do
2013 2014 2015 2016
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .once
        .and_return(double(:tree, path: 'logo.png'))
2017

2018
      2.times { expect(repository.avatar).to eq('logo.png') }
2019 2020
    end
  end
2021

2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
  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

2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061
  describe '#xcode_project?' do
    before do
      allow(repository).to receive(:tree).with(:head).and_return(double(:tree, blobs: [blob]))
    end

    context 'when the root contains a *.xcodeproj file' do
      let(:blob) { double(:blob, path: 'Foo.xcodeproj') }

      it 'returns true' do
        expect(repository.xcode_project?).to be_truthy
      end
    end

    context 'when the root contains a *.xcworkspace file' do
      let(:blob) { double(:blob, path: 'Foo.xcworkspace') }

      it 'returns true' do
        expect(repository.xcode_project?).to be_truthy
      end
    end

    context 'when the root contains no XCode config file' do
      let(:blob) { double(:blob, path: 'subdir/Foo.xcworkspace') }

      it 'returns false' do
        expect(repository.xcode_project?).to be_falsey
      end
    end
  end

2062
  describe "#keep_around" do
2063 2064 2065 2066
    it "does not fail if we attempt to reference bad commit" do
      expect(repository.kept_around?('abc1234')).to be_falsey
    end

2067 2068 2069 2070 2071
    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
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087

    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
2088
  end
2089

2090
  describe '#update_ref' do
2091
    it 'can create a ref' do
2092
      Gitlab::Git::OperationService.new(nil, repository.raw_repository).send(:update_ref, 'refs/heads/foobar', 'refs/heads/master', Gitlab::Git::BLANK_SHA)
2093 2094 2095 2096 2097 2098

      expect(repository.find_branch('foobar')).not_to be_nil
    end

    it 'raises CommitError when the ref update fails' do
      expect do
2099 2100
        Gitlab::Git::OperationService.new(nil, repository.raw_repository).send(:update_ref, 'refs/heads/master', 'refs/heads/master', Gitlab::Git::BLANK_SHA)
      end.to raise_error(Gitlab::Git::CommitError)
2101 2102
    end
  end
2103

2104
  describe '#contribution_guide', :use_clean_rails_memory_store_caching do
2105
    it 'returns and caches the output' do
2106 2107 2108 2109
      expect(repository).to receive(:file_on_head)
        .with(:contributing)
        .and_return(Gitlab::Git::Tree.new(path: 'CONTRIBUTING.md'))
        .once
2110 2111

      2.times do
2112 2113
        expect(repository.contribution_guide)
          .to be_an_instance_of(Gitlab::Git::Tree)
2114 2115 2116 2117
      end
    end
  end

2118
  describe '#gitignore', :use_clean_rails_memory_store_caching do
2119
    it 'returns and caches the output' do
2120 2121 2122 2123
      expect(repository).to receive(:file_on_head)
        .with(:gitignore)
        .and_return(Gitlab::Git::Tree.new(path: '.gitignore'))
        .once
2124 2125

      2.times do
2126
        expect(repository.gitignore).to be_an_instance_of(Gitlab::Git::Tree)
2127 2128 2129 2130
      end
    end
  end

2131
  describe '#koding_yml', :use_clean_rails_memory_store_caching do
2132
    it 'returns and caches the output' do
2133 2134 2135 2136
      expect(repository).to receive(:file_on_head)
        .with(:koding)
        .and_return(Gitlab::Git::Tree.new(path: '.koding.yml'))
        .once
2137 2138

      2.times do
2139
        expect(repository.koding_yml).to be_an_instance_of(Gitlab::Git::Tree)
2140 2141 2142 2143
      end
    end
  end

2144
  describe '#readme', :use_clean_rails_memory_store_caching do
2145 2146
    context 'with a non-existing repository' do
      it 'returns nil' do
2147
        allow(repository).to receive(:tree).with(:head).and_return(nil)
2148

2149 2150 2151
        expect(repository.readme).to be_nil
      end
    end
2152

2153
    context 'with an existing repository' do
2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
      context 'when no README exists' do
        it 'returns nil' do
          allow_any_instance_of(Tree).to receive(:readme).and_return(nil)

          expect(repository.readme).to be_nil
        end
      end

      context 'when a README exists' do
        it 'returns the README' do
          expect(repository.readme).to be_an_instance_of(ReadmeBlob)
        end
2166 2167 2168 2169
      end
    end
  end

2170 2171
  describe '#expire_statistics_caches' do
    it 'expires the caches' do
2172 2173
      expect(repository).to receive(:expire_method_caches)
        .with(%i(size commit_count))
2174

2175 2176 2177 2178 2179 2180
      repository.expire_statistics_caches
    end
  end

  describe '#expire_all_method_caches' do
    it 'expires the caches of all methods' do
2181 2182
      expect(repository).to receive(:expire_method_caches)
        .with(Repository::CACHED_METHODS)
2183 2184 2185

      repository.expire_all_method_caches
    end
2186 2187 2188 2189 2190 2191 2192 2193 2194

    it 'all cache_method definitions are in the lists of method caches' do
      methods = repository.methods.map do |method|
        match = /^_uncached_(.*)/.match(method)
        match[1].to_sym if match
      end.compact

      expect(methods).to match_array(Repository::CACHED_METHODS + Repository::MEMOIZED_CACHED_METHODS)
    end
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
  end

  describe '#file_on_head' do
    context 'with a non-existing repository' do
      it 'returns nil' do
        expect(repository).to receive(:tree).with(:head).and_return(nil)

        expect(repository.file_on_head(:readme)).to be_nil
      end
    end

    context 'with a repository that has no blobs' do
      it 'returns nil' do
        expect_any_instance_of(Tree).to receive(:blobs).and_return([])

        expect(repository.file_on_head(:readme)).to be_nil
      end
    end

    context 'with an existing repository' do
      it 'returns a Gitlab::Git::Tree' do
2216 2217
        expect(repository.file_on_head(:readme))
          .to be_an_instance_of(Gitlab::Git::Tree)
2218 2219 2220 2221
      end
    end
  end

2222 2223 2224 2225 2226 2227
  describe '#head_tree' do
    context 'with an existing repository' do
      it 'returns a Tree' do
        expect(repository.head_tree).to be_an_instance_of(Tree)
      end
    end
2228

2229 2230 2231 2232 2233
    context 'with a non-existing repository' do
      it 'returns nil' do
        expect(repository).to receive(:head_commit).and_return(nil)

        expect(repository.head_tree).to be_nil
2234 2235 2236 2237
      end
    end
  end

2238 2239 2240 2241 2242
  describe '#tree' do
    context 'using a non-existing repository' do
      before do
        allow(repository).to receive(:head_commit).and_return(nil)
      end
2243

2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
      it 'returns nil' do
        expect(repository.tree(:head)).to be_nil
      end

      it 'returns nil when using a path' do
        expect(repository.tree(:head, 'README.md')).to be_nil
      end
    end

    context 'using an existing repository' do
      it 'returns a Tree' do
        expect(repository.tree(:head)).to be_an_instance_of(Tree)
      end
    end
  end

  describe '#size' do
    context 'with a non-existing repository' do
      it 'returns 0' do
        expect(repository).to receive(:exists?).and_return(false)

        expect(repository.size).to eq(0.0)
      end
    end

    context 'with an existing repository' do
      it 'returns the repository size as a Float' do
        expect(repository.size).to be_an_instance_of(Float)
      end
    end
  end

  describe '#commit_count' do
    context 'with a non-existing repository' do
      it 'returns 0' do
        expect(repository).to receive(:root_ref).and_return(nil)

        expect(repository.commit_count).to eq(0)
      end
    end

    context 'with an existing repository' do
      it 'returns the commit count' do
Douwe Maan's avatar
Douwe Maan committed
2287
        expect(repository.commit_count).to be_an(Integer)
2288 2289 2290 2291
      end
    end
  end

2292
  describe '#commit_count_for_ref' do
2293
    let(:project) { create :project }
2294

2295 2296
    context 'with a non-existing repository' do
      it 'returns 0' do
2297 2298 2299 2300 2301 2302 2303 2304
        expect(project.repository.commit_count_for_ref('master')).to eq(0)
      end
    end

    context 'with empty repository' do
      it 'returns 0' do
        project.create_repository
        expect(project.repository.commit_count_for_ref('master')).to eq(0)
2305 2306 2307 2308 2309 2310 2311 2312 2313 2314
      end
    end

    context 'when searching for the root ref' do
      it 'returns the same count as #commit_count' do
        expect(repository.commit_count_for_ref(repository.root_ref)).to eq(repository.commit_count)
      end
    end
  end

2315 2316 2317 2318 2319 2320 2321 2322 2323
  describe '#diverging_commit_counts' do
    it 'returns the commit counts behind and ahead of default branch' do
      result = repository.diverging_commit_counts(
        repository.find_branch('fix'))

      expect(result).to eq(behind: 29, ahead: 2)
    end
  end

2324 2325
  describe '#refresh_method_caches' do
    it 'refreshes the caches of the given types' do
2326 2327
      expect(repository).to receive(:expire_method_caches)
        .with(%i(rendered_readme license_blob license_key license))
2328

2329
      expect(repository).to receive(:rendered_readme)
2330 2331
      expect(repository).to receive(:license_blob)
      expect(repository).to receive(:license_key)
2332
      expect(repository).to receive(:license)
2333 2334 2335

      repository.refresh_method_caches(%i(readme license))
    end
2336
  end
Douwe Maan's avatar
Douwe Maan committed
2337 2338 2339

  describe '#gitlab_ci_yml_for' do
    before do
2340
      repository.create_file(User.last, '.gitlab-ci.yml', 'CONTENT', message: 'Add .gitlab-ci.yml', branch_name: 'master')
Douwe Maan's avatar
Douwe Maan committed
2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
    end

    context 'when there is a .gitlab-ci.yml at the commit' do
      it 'returns the content' do
        expect(repository.gitlab_ci_yml_for(repository.commit.sha)).to eq('CONTENT')
      end
    end

    context 'when there is no .gitlab-ci.yml at the commit' do
      it 'returns nil' do
        expect(repository.gitlab_ci_yml_for(repository.commit.parent.sha)).to be_nil
      end
    end
  end

  describe '#route_map_for' do
    before do
2358
      repository.create_file(User.last, '.gitlab/route-map.yml', 'CONTENT', message: 'Add .gitlab/route-map.yml', branch_name: 'master')
Douwe Maan's avatar
Douwe Maan committed
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372
    end

    context 'when there is a .gitlab/route-map.yml at the commit' do
      it 'returns the content' do
        expect(repository.route_map_for(repository.commit.sha)).to eq('CONTENT')
      end
    end

    context 'when there is no .gitlab/route-map.yml at the commit' do
      it 'returns nil' do
        expect(repository.route_map_for(repository.commit.parent.sha)).to be_nil
      end
    end
  end
2373

2374 2375 2376 2377 2378
  def create_remote_branch(remote_name, branch_name, target)
    rugged = repository.rugged
    rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", target.id)
  end

2379
  describe '#ancestor?' do
2380 2381
    let(:commit) { repository.commit }
    let(:ancestor) { commit.parents.first }
2382

2383
    shared_examples '#ancestor?' do
2384
      it 'it is an ancestor' do
2385
        expect(repository.ancestor?(ancestor.id, commit.id)).to eq(true)
2386 2387 2388
      end

      it 'it is not an ancestor' do
2389
        expect(repository.ancestor?(commit.id, ancestor.id)).to eq(false)
2390 2391 2392
      end

      it 'returns false on nil-values' do
2393 2394 2395
        expect(repository.ancestor?(nil, commit.id)).to eq(false)
        expect(repository.ancestor?(ancestor.id, nil)).to eq(false)
        expect(repository.ancestor?(nil, nil)).to eq(false)
2396
      end
2397

2398 2399 2400
      it 'returns false for invalid commit IDs' do
        expect(repository.ancestor?(commit.id, Gitlab::Git::BLANK_SHA)).to eq(false)
        expect(repository.ancestor?( Gitlab::Git::BLANK_SHA, commit.id)).to eq(false)
2401
      end
2402
    end
2403

2404 2405 2406
    context 'with Gitaly enabled' do
      it_behaves_like('#ancestor?')
    end
2407

2408 2409
    context 'with Gitaly disabled', :skip_gitaly_mock do
      it_behaves_like('#ancestor?')
2410 2411
    end
  end
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431

  describe 'commit cache' do
    set(:project) { create(:project, :repository) }

    it 'caches based on SHA' do
      # Gets the commit oid, and warms the cache
      oid = project.commit.id

      expect(Gitlab::Git::Commit).not_to receive(:find).once

      project.commit_by(oid: oid)
    end

    it 'caches nil values' do
      expect(Gitlab::Git::Commit).to receive(:find).once

      project.commit_by(oid: '1' * 40)
      project.commit_by(oid: '1' * 40)
    end
  end
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451

  describe '#raw_repository' do
    subject { repository.raw_repository }

    it 'returns a Gitlab::Git::Repository representation of the repository' do
      expect(subject).to be_a(Gitlab::Git::Repository)
      expect(subject.relative_path).to eq(project.disk_path + '.git')
      expect(subject.gl_repository).to eq("project-#{project.id}")
    end

    context 'with a wiki repository' do
      let(:repository) { project.wiki.repository }

      it 'creates a Gitlab::Git::Repository with the proper attributes' do
        expect(subject).to be_a(Gitlab::Git::Repository)
        expect(subject.relative_path).to eq(project.disk_path + '.wiki.git')
        expect(subject.gl_repository).to eq("wiki-#{project.id}")
      end
    end
  end
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558

  describe '#contributors' do
    let(:author_a) { build(:author, email: 'tiagonbotelho@hotmail.com', name: 'tiagonbotelho') }
    let(:author_b) { build(:author, email: 'gitlab@winniehell.de', name: 'Winnie') }
    let(:author_c) { build(:author, email: 'douwe@gitlab.com', name: 'Douwe Maan') }
    let(:stubbed_commits) do
      [build(:commit, author: author_a),
       build(:commit, author: author_a),
       build(:commit, author: author_b),
       build(:commit, author: author_c),
       build(:commit, author: author_c),
       build(:commit, author: author_c)]
    end
    let(:order_by) { nil }
    let(:sort) { nil }

    before do
      allow(repository).to receive(:commits).with(nil, limit: 2000, offset: 0, skip_merges: true).and_return(stubbed_commits)
    end

    subject { repository.contributors(order_by: order_by, sort: sort) }

    def expect_contributors(*contributors)
      expect(subject.map(&:email)).to eq(contributors.map(&:email))
    end

    it 'returns the array of Gitlab::Contributor for the repository' do
      expect_contributors(author_a, author_b, author_c)
    end

    context 'order_by email' do
      let(:order_by) { 'email' }

      context 'asc' do
        let(:sort) { 'asc' }

        it 'returns all the contributors ordered by email asc case insensitive' do
          expect_contributors(author_c, author_b, author_a)
        end
      end

      context 'desc' do
        let(:sort) { 'desc' }

        it 'returns all the contributors ordered by email desc case insensitive' do
          expect_contributors(author_a, author_b, author_c)
        end
      end
    end

    context 'order_by name' do
      let(:order_by) { 'name' }

      context 'asc' do
        let(:sort) { 'asc' }

        it 'returns all the contributors ordered by name asc case insensitive' do
          expect_contributors(author_c, author_a, author_b)
        end
      end

      context 'desc' do
        let(:sort) { 'desc' }

        it 'returns all the contributors ordered by name desc case insensitive' do
          expect_contributors(author_b, author_a, author_c)
        end
      end
    end

    context 'order_by commits' do
      let(:order_by) { 'commits' }

      context 'asc' do
        let(:sort) { 'asc' }

        it 'returns all the contributors ordered by commits asc' do
          expect_contributors(author_b, author_a, author_c)
        end
      end

      context 'desc' do
        let(:sort) { 'desc' }

        it 'returns all the contributors ordered by commits desc' do
          expect_contributors(author_c, author_a, author_b)
        end
      end
    end

    context 'invalid ordering' do
      let(:order_by) { 'unknown' }

      it 'returns the contributors unsorted' do
        expect_contributors(author_a, author_b, author_c)
      end
    end

    context 'invalid sorting' do
      let(:order_by) { 'name' }
      let(:sort) { 'unknown' }

      it 'returns the contributors unsorted' do
        expect_contributors(author_a, author_b, author_c)
      end
    end
  end
2559
end