BigW Consortium Gitlab

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

Douwe Maan committed
3
describe Repository, models: true do
4
  include RepoHelpers
5
  TestBlob = Struct.new(:name)
6

7 8
  let(:project) { create(:project) }
  let(:repository) { project.repository }
9
  let(:user) { create(:user) }
10 11 12 13
  let(:commit_options) do
    author = repository.user_to_committer(user)
    { message: 'Test message', committer: author, author: author }
  end
14
  let(:merge_commit) do
15 16 17
    merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
    merge_commit_id = repository.merge(user, merge_request, commit_options)
    repository.commit(merge_commit_id)
18
  end
19

20
  describe '#branch_names_contains' do
21 22
    subject { repository.branch_names_contains(sample_commit.id) }

23 24 25
    it { is_expected.to include('master') }
    it { is_expected.not_to include('feature') }
    it { is_expected.not_to include('fix') }
26
  end
27

28
  describe '#tag_names_contains' do
29
    subject { repository.tag_names_contains(sample_commit.id) }
30

31 32
    it { is_expected.to include('v1.1.0') }
    it { is_expected.not_to include('v1.0.0') }
33 34
  end

35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
  describe 'tags_sorted_by' do
    context 'name' do
      subject { repository.tags_sorted_by('name').map(&:name) }

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

    context 'updated' do
      let(:tag_a) { repository.find_tag('v1.0.0') }
      let(:tag_b) { repository.find_tag('v1.1.0') }

      context 'desc' do
        subject { repository.tags_sorted_by('updated_desc').map(&:name) }

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

53 54 55
          allow(tag_a).to receive(:target).and_return(double_first)
          allow(tag_b).to receive(:target).and_return(double_last)
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
56 57 58 59 60 61 62 63 64 65 66 67
        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)

68 69 70
          allow(tag_a).to receive(:target).and_return(double_last)
          allow(tag_b).to receive(:target).and_return(double_first)
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
71 72 73 74 75 76 77
        end

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

78
  describe '#last_commit_for_path' do
79
    subject { repository.last_commit_for_path(sample_commit.id, '.gitignore').id }
80

81
    it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
82
  end
83

84
  describe '#find_commits_by_message' do
85
    subject { repository.find_commits_by_message('submodule').map{ |k| k.id } }
86 87 88 89 90 91 92

    it { is_expected.to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e') }
    it { is_expected.to include('6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9') }
    it { is_expected.to include('cfe32cf61b73a0d5e9f13e774abde7ff789b1660') }
    it { is_expected.not_to include('913c66a37b4a45b9769037c55c2d238bd0942d2e') }
  end

93
  describe '#blob_at' do
94 95 96 97 98 99
    context 'blank sha' do
      subject { repository.blob_at(Gitlab::Git::BLANK_SHA, '.gitignore') }

      it { is_expected.to be_nil }
    end
  end
100

101
  describe '#merged_to_root_ref?' do
102 103 104 105 106
    context 'merged branch' do
      subject { repository.merged_to_root_ref?('improve/awesome') }

      it { is_expected.to be_truthy }
    end
107 108
  end

109
  describe '#can_be_merged?' do
110 111 112 113 114 115 116 117 118 119 120
    context 'mergeable branches' do
      subject { repository.can_be_merged?('0b4bc9a49b562e85de7cc9e834518ea6828729b9', 'master') }

      it { is_expected.to be_truthy }
    end

    context 'non-mergeable branches' do
      subject { repository.can_be_merged?('bb5206fee213d983da88c47f9cf4cc6caf9c66dc', 'feature') }

      it { is_expected.to be_falsey }
    end
121 122 123 124 125 126 127 128 129 130 131 132

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

      it { is_expected.to be_falsey }
    end

    context 'non existent branch' do
      subject { repository.merged_to_root_ref?('non_existent_branch') }

      it { is_expected.to be_nil }
    end
133 134
  end

135
  describe :commit_file do
136 137
    it 'commits change to a file successfully' do
      expect do
138 139
        repository.commit_file(user, 'CHANGELOG', 'Changelog!',
                              'Updates file content',
140 141 142
                              'master', true)
      end.to change { repository.commits('master').count }.by(1)

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

145
      expect(blob.data).to eq('Changelog!')
146 147 148
    end
  end

149 150
  describe :update_file do
    it 'updates filename successfully' do
151 152
      expect do
        repository.update_file(user, 'NEWLICENSE', 'Copyright!',
153 154
                                     branch: 'master',
                                     previous_path: 'LICENSE',
155 156
                                     message: 'Changes filename')
      end.to change { repository.commits('master').count }.by(1)
157 158 159 160 161 162 163 164

      files = repository.ls_files('master')

      expect(files).not_to include('LICENSE')
      expect(files).to include('NEWLICENSE')
    end
  end

165 166 167 168 169 170
  describe "search_files" do
    let(:results) { repository.search_files('feature', 'master') }
    subject { results }

    it { is_expected.to be_an Array }

171 172 173 174 175 176
    it 'regex-escapes the query string' do
      results = repository.search_files("test\\", 'master')

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

177 178 179 180 181 182
    it 'properly handles an unmatched parenthesis' do
      results = repository.search_files("test(", 'master')

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

183 184 185 186 187 188 189 190
    describe 'result' do
      subject { results.first }

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

    describe 'parsing result' do
191 192
      subject { repository.parse_search_result(search_result) }
      let(:search_result) { results.first }
193 194 195

      it { is_expected.to be_an OpenStruct }
      it { expect(subject.filename).to eq('CHANGELOG') }
196
      it { expect(subject.basename).to eq('CHANGELOG') }
197 198 199
      it { expect(subject.ref).to eq('master') }
      it { expect(subject.startline).to eq(186) }
      it { expect(subject.data.lines[2]).to eq("  - Feature: Replace teams with group membership\n") }
200 201 202 203 204 205 206 207 208 209 210 211 212 213

      context "when filename has extension" do
        let(:search_result) { "master:CONTRIBUTE.md:5:- [Contribute to GitLab](#contribute-to-gitlab)\n" }

        it { expect(subject.filename).to eq('CONTRIBUTE.md') }
        it { expect(subject.basename).to eq('CONTRIBUTE') }
      end

      context "when file under directory" do
        let(:search_result) { "master:a/b/c.md:5:a b c\n" }

        it { expect(subject.filename).to eq('a/b/c.md') }
        it { expect(subject.basename).to eq('a/b/c') }
      end
214 215
    end
  end
216

217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
  describe "#changelog" do
    before do
      repository.send(:cache).expire(:changelog)
    end

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

      expect(repository.changelog.name).to eq('changelog')
    end

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

      expect(repository.changelog.name).to eq('news')
    end

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

      expect(repository.changelog.name).to eq('history')
    end

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

      expect(repository.changelog.name).to eq('changes')
    end

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

      expect(repository.changelog.name).to eq('CHANGELOG')
    end
  end

  describe "#license_blob" do
254
    before do
255 256
      repository.send(:cache).expire(:license_blob)
      repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'master')
257 258
    end

259 260 261 262 263 264 265 266 267
    it 'handles when HEAD points to non-existent ref' do
      repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
      rugged = double('rugged')
      expect(rugged).to receive(:head_unborn?).and_return(true)
      expect(repository).to receive(:rugged).and_return(rugged)

      expect(repository.license_blob).to be_nil
    end

268 269 270 271 272 273 274
    it 'looks in the root_ref only' do
      repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'markdown')
      repository.commit_file(user, 'LICENSE', Licensee::License.new('mit').content, 'Add LICENSE', 'markdown', false)

      expect(repository.license_blob).to be_nil
    end

275 276
    it 'detects license file with no recognizable open-source license content' do
      repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
277 278 279 280

      expect(repository.license_blob.name).to eq('LICENSE')
    end

281 282 283
    %w[LICENSE LICENCE LiCensE LICENSE.md LICENSE.foo COPYING COPYING.md].each do |filename|
      it "detects '#{filename}'" do
        repository.commit_file(user, filename, Licensee::License.new('mit').content, "Add #{filename}", 'master', false)
284

285 286
        expect(repository.license_blob.name).to eq(filename)
      end
287 288 289 290 291 292 293 294
    end
  end

  describe '#license_key' do
    before do
      repository.send(:cache).expire(:license_key)
      repository.remove_file(user, 'LICENSE', 'Remove LICENSE', 'master')
    end
295

296 297 298 299 300 301 302 303 304
    it 'handles when HEAD points to non-existent ref' do
      repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)
      rugged = double('rugged')
      expect(rugged).to receive(:head_unborn?).and_return(true)
      expect(repository).to receive(:rugged).and_return(rugged)

      expect(repository.license_key).to be_nil
    end

305 306 307 308 309 310 311 312
    it 'returns nil when no license is detected' do
      expect(repository.license_key).to be_nil
    end

    it 'detects license file with no recognizable open-source license content' do
      repository.commit_file(user, 'LICENSE', 'Copyright!', 'Add LICENSE', 'master', false)

      expect(repository.license_key).to be_nil
313
    end
314

315 316
    it 'returns the license key' do
      repository.commit_file(user, 'LICENSE', Licensee::License.new('mit').content, 'Add LICENSE', 'master', false)
317

318
      expect(repository.license_key).to eq('mit')
319
    end
320
  end
321

322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
  describe "#gitlab_ci_yml" do
    it 'returns valid file' do
      files = [TestBlob.new('file'), TestBlob.new('.gitlab-ci.yml'), TestBlob.new('copying')]
      expect(repository.tree).to receive(:blobs).and_return(files)

      expect(repository.gitlab_ci_yml.name).to eq('.gitlab-ci.yml')
    end

    it 'returns nil if not exists' do
      expect(repository.tree).to receive(:blobs).and_return([])
      expect(repository.gitlab_ci_yml).to be_nil
    end

    it 'returns nil for empty repository' do
      expect(repository).to receive(:empty?).and_return(true)
      expect(repository.gitlab_ci_yml).to be_nil
    end
  end

341
  describe '#add_branch' do
342
    context 'when pre hooks were successful' do
343
      it 'runs without errors' do
344
        hook = double(trigger: [true, nil])
345
        expect(Gitlab::Git::Hook).to receive(:new).exactly(3).times.and_return(hook)
346 347 348 349

        expect { repository.add_branch(user, 'new_feature', 'master') }.not_to raise_error
      end

350
      it 'creates the branch' do
351
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
352 353 354 355 356

        branch = repository.add_branch(user, 'new_feature', 'master')

        expect(branch.name).to eq('new_feature')
      end
357 358 359 360 361 362

      it 'calls the after_create_branch hook' do
        expect(repository).to receive(:after_create_branch)

        repository.add_branch(user, 'new_feature', 'master')
      end
363 364 365
    end

    context 'when pre hooks failed' do
366
      it 'gets an error' do
367
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
368 369 370 371 372 373

        expect do
          repository.add_branch(user, 'new_feature', 'master')
        end.to raise_error(GitHooksService::PreReceiveError)
      end

374
      it 'does not create the branch' do
375
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
376 377 378 379 380 381 382 383 384

        expect do
          repository.add_branch(user, 'new_feature', 'master')
        end.to raise_error(GitHooksService::PreReceiveError)
        expect(repository.find_branch('new_feature')).to be_nil
      end
    end
  end

385
  describe '#rm_branch' do
386 387 388
    let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature
    let(:blank_sha) { '0000000000000000000000000000000000000000' }

389
    context 'when pre hooks were successful' do
390
      it 'runs without errors' do
391 392
        expect_any_instance_of(GitHooksService).to receive(:execute).
          with(user, project.repository.path_to_repo, old_rev, blank_sha, 'refs/heads/feature')
393 394 395 396

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

397
      it 'deletes the branch' do
398
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, nil])
399 400 401 402 403 404 405 406

        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
407
      it 'gets an error' do
408
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
409 410 411 412 413 414

        expect do
          repository.rm_branch(user, 'new_feature')
        end.to raise_error(GitHooksService::PreReceiveError)
      end

415
      it 'does not delete the branch' do
416
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
417 418 419 420 421 422 423 424 425

        expect do
          repository.rm_branch(user, 'feature')
        end.to raise_error(GitHooksService::PreReceiveError)
        expect(repository.find_branch('feature')).not_to be_nil
      end
    end
  end

426
  describe '#commit_with_hooks' do
427 428
    let(:old_rev) { '0b4bc9a49b562e85de7cc9e834518ea6828729b9' } # git rev-parse feature

429
    context 'when pre hooks were successful' do
430 431
      before do
        expect_any_instance_of(GitHooksService).to receive(:execute).
432 433
          with(user, repository.path_to_repo, old_rev, sample_commit.id, 'refs/heads/feature').
          and_yield.and_return(true)
434
      end
435

436
      it 'runs without errors' do
437 438 439 440
        expect do
          repository.commit_with_hooks(user, 'feature') { sample_commit.id }
        end.not_to raise_error
      end
441

442
      it 'ensures the autocrlf Git option is set to :input' do
443 444 445 446
        expect(repository).to receive(:update_autocrlf_option)

        repository.commit_with_hooks(user, 'feature') { sample_commit.id }
      end
447 448 449 450 451 452 453 454

      context "when the branch wasn't empty" do
        it 'updates the head' do
          expect(repository.find_branch('feature').target.id).to eq(old_rev)
          repository.commit_with_hooks(user, 'feature') { sample_commit.id }
          expect(repository.find_branch('feature').target.id).to eq(sample_commit.id)
        end
      end
455 456 457
    end

    context 'when pre hooks failed' do
458
      it 'gets an error' do
459
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([false, ''])
460 461 462 463 464 465

        expect do
          repository.commit_with_hooks(user, 'feature') { sample_commit.id }
        end.to raise_error(GitHooksService::PreReceiveError)
      end
    end
466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502

    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

      it 'expires branch cache' do
        expect(repository).not_to receive(:expire_exists_cache)
        expect(repository).not_to receive(:expire_root_ref_cache)
        expect(repository).not_to receive(:expire_emptiness_caches)
        expect(repository).to     receive(:expire_branches_cache)
        expect(repository).to     receive(:expire_has_visible_content_cache)
        expect(repository).to     receive(:expire_branch_count_cache)

        repository.commit_with_hooks(user, 'new-feature') { sample_commit.id }
      end
    end

    context 'when repository is empty' do
      before do
        allow_any_instance_of(Gitlab::Git::Hook).to receive(:trigger).and_return([true, ''])
      end

      it 'expires creation and branch cache' do
        empty_repository = create(:empty_project, :empty_repo).repository

        expect(empty_repository).to receive(:expire_exists_cache)
        expect(empty_repository).to receive(:expire_root_ref_cache)
        expect(empty_repository).to receive(:expire_emptiness_caches)
        expect(empty_repository).to receive(:expire_branches_cache)
        expect(empty_repository).to receive(:expire_has_visible_content_cache)
        expect(empty_repository).to receive(:expire_branch_count_cache)

        empty_repository.commit_file(user, 'CHANGELOG', 'Changelog!',
                                     'Updates file content', 'master', false)
      end
    end
503
  end
504

505 506 507 508 509 510 511 512 513 514 515
  describe '#exists?' do
    it 'returns true when a repository exists' do
      expect(repository.exists?).to eq(true)
    end

    it 'returns false when a repository does not exist' do
      expect(repository.raw_repository).to receive(:rugged).
        and_raise(Gitlab::Git::Repository::NoRepository)

      expect(repository.exists?).to eq(false)
    end
516 517 518 519 520 521

    it 'returns false when there is no namespace' do
      allow(repository).to receive(:path_with_namespace).and_return(nil)

      expect(repository.exists?).to eq(false)
    end
522 523
  end

524 525 526 527 528
  describe '#has_visible_content?' do
    subject { repository.has_visible_content? }

    describe 'when there are no branches' do
      before do
529
        allow(repository).to receive(:branch_count).and_return(0)
530 531 532 533 534 535
      end

      it { is_expected.to eq(false) }
    end

    describe 'when there are branches' do
536
      it 'returns true' do
537
        expect(repository).to receive(:branch_count).and_return(3)
538 539 540 541 542

        expect(subject).to eq(true)
      end

      it 'caches the output' do
543
        expect(repository).to receive(:branch_count).
544 545 546 547 548
          once.
          and_return(3)

        repository.has_visible_content?
        repository.has_visible_content?
549
      end
550 551 552
    end
  end

553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571
  describe '#update_autocrlf_option' do
    describe 'when autocrlf is not already set to :input' do
      before do
        repository.raw_repository.autocrlf = true
      end

      it 'sets autocrlf to :input' do
        repository.update_autocrlf_option

        expect(repository.raw_repository.autocrlf).to eq(:input)
      end
    end

    describe 'when autocrlf is already set to :input' do
      before do
        repository.raw_repository.autocrlf = :input
      end

      it 'does nothing' do
572
        expect(repository.raw_repository).not_to receive(:autocrlf=).
573 574 575 576 577 578 579
          with(:input)

        repository.update_autocrlf_option
      end
    end
  end

580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621
  describe '#empty?' do
    let(:empty_repository) { create(:project_empty_repo).repository }

    it 'returns true for an empty repository' do
      expect(empty_repository.empty?).to eq(true)
    end

    it 'returns false for a non-empty repository' do
      expect(repository.empty?).to eq(false)
    end

    it 'caches the output' do
      expect(repository.raw_repository).to receive(:empty?).
        once.
        and_return(false)

      repository.empty?
      repository.empty?
    end
  end

  describe '#root_ref' do
    it 'returns a branch name' do
      expect(repository.root_ref).to be_an_instance_of(String)
    end

    it 'caches the output' do
      expect(repository.raw_repository).to receive(:root_ref).
        once.
        and_return('master')

      repository.root_ref
      repository.root_ref
    end
  end

  describe '#expire_cache' do
    it 'expires all caches' do
      expect(repository).to receive(:expire_branch_cache)

      repository.expire_cache
    end
622 623 624 625 626 627

    it 'expires the caches for a specific branch' do
      expect(repository).to receive(:expire_branch_cache).with('master')

      repository.expire_cache('master')
    end
628

629
    it 'expires the emptiness caches for an empty repository' do
630 631 632 633 634 635
      expect(repository).to receive(:empty?).and_return(true)
      expect(repository).to receive(:expire_emptiness_caches)

      repository.expire_cache
    end

636
    it 'does not expire the emptiness caches for a non-empty repository' do
637
      expect(repository).to receive(:empty?).and_return(false)
638
      expect(repository).not_to receive(:expire_emptiness_caches)
639 640 641

      repository.expire_cache
    end
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661
  end

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

      expect(repository.raw_repository).to receive(:root_ref).
        once.
        and_return('foo')

      repository.expire_root_ref_cache

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

  describe '#expire_has_visible_content_cache' do
    it 'expires the visible content cache' do
      repository.has_visible_content?

662
      expect(repository).to receive(:branch_count).
663 664 665 666
        once.
        and_return(0)

      repository.expire_has_visible_content_cache
667

668
      expect(repository.has_visible_content?).to eq(false)
669 670
    end
  end
671

672
  describe '#expire_branch_cache' do
673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698
    # This method is private but we need it for testing purposes. Sadly there's
    # no other proper way of testing caching operations.
    let(:cache) { repository.send(:cache) }

    it 'expires the cache for all branches' do
      expect(cache).to receive(:expire).
        at_least(repository.branches.length).
        times

      repository.expire_branch_cache
    end

    it 'expires the cache for all branches when the root branch is given' do
      expect(cache).to receive(:expire).
        at_least(repository.branches.length).
        times

      repository.expire_branch_cache(repository.root_ref)
    end

    it 'expires the cache for a specific branch' do
      expect(cache).to receive(:expire).once

      repository.expire_branch_cache('foo')
    end
  end
699

700 701 702 703 704 705 706 707 708 709 710
  describe '#expire_emptiness_caches' do
    let(:cache) { repository.send(:cache) }

    it 'expires the caches' do
      expect(cache).to receive(:expire).with(:empty?)
      expect(repository).to receive(:expire_has_visible_content_cache)

      repository.expire_emptiness_caches
    end
  end

711
  describe :skip_merged_commit do
712
    subject { repository.commits(Gitlab::Git::BRANCH_REF_PREFIX + "'test'", limit: 100, skip_merges: true).map{ |k| k.id } }
713 714 715

    it { is_expected.not_to include('e56497bb5f03a90a51293fc6d516788730953899') }
  end
716 717

  describe '#merge' do
718
    it 'merges the code and return the commit id' do
719 720
      expect(merge_commit).to be_present
      expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
721 722 723
    end
  end

724 725 726
  describe '#revert' do
    let(:new_image_commit) { repository.commit('33f3729a45c02fc67d00adb1b8bca394b0e761d9') }
    let(:update_image_commit) { repository.commit('2f63565e7aac07bcdadb654e253078b727143ec4') }
727

728
    context 'when there is a conflict' do
729
      it 'aborts the operation' do
730 731 732 733 734
        expect(repository.revert(user, new_image_commit, 'master')).to eq(false)
      end
    end

    context 'when commit was already reverted' do
735
      it 'aborts the operation' do
736 737 738 739 740 741 742
        repository.revert(user, update_image_commit, 'master')

        expect(repository.revert(user, update_image_commit, 'master')).to eq(false)
      end
    end

    context 'when commit can be reverted' do
743
      it 'reverts the changes' do
744 745 746 747 748
        expect(repository.revert(user, update_image_commit, 'master')).to be_truthy
      end
    end

    context 'reverting a merge commit' do
749
      it 'reverts the changes' do
750 751 752 753 754 755
        merge_commit
        expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).to be_present

        repository.revert(user, merge_commit, 'master')
        expect(repository.blob_at_branch('master', 'files/ruby/feature.rb')).not_to be_present
      end
756 757
    end
  end
758

759 760 761 762 763 764
  describe '#cherry_pick' do
    let(:conflict_commit) { repository.commit('c642fe9b8b9f28f9225d7ea953fe14e74748d53b') }
    let(:pickable_commit) { repository.commit('7d3b0f7cff5f37573aea97cebfd5692ea1689924') }
    let(:pickable_merge) { repository.commit('e56497bb5f03a90a51293fc6d516788730953899') }

    context 'when there is a conflict' do
765
      it 'aborts the operation' do
766 767 768 769 770
        expect(repository.cherry_pick(user, conflict_commit, 'master')).to eq(false)
      end
    end

    context 'when commit was already cherry-picked' do
771
      it 'aborts the operation' do
772 773 774 775 776 777 778
        repository.cherry_pick(user, pickable_commit, 'master')

        expect(repository.cherry_pick(user, pickable_commit, 'master')).to eq(false)
      end
    end

    context 'when commit can be cherry-picked' do
779
      it 'cherry-picks the changes' do
780 781 782 783 784
        expect(repository.cherry_pick(user, pickable_commit, 'master')).to be_truthy
      end
    end

    context 'cherry-picking a merge commit' do
785
      it 'cherry-picks the changes' do
786 787 788 789 790 791 792 793
        expect(repository.blob_at_branch('master', 'foo/bar/.gitkeep')).to be_nil

        repository.cherry_pick(user, pickable_merge, 'master')
        expect(repository.blob_at_branch('master', 'foo/bar/.gitkeep')).not_to be_nil
      end
    end
  end

794 795 796 797 798 799 800
  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
801
        expect(repository).not_to receive(:expire_cache)
802 803 804 805

        repository.before_delete
      end

806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
      it 'flushes the tags cache' do
        expect(repository).to receive(:expire_tags_cache)

        repository.before_delete
      end

      it 'flushes the tag count cache' do
        expect(repository).to receive(:expire_tag_count_cache)

        repository.before_delete
      end

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

        repository.before_delete
      end

      it 'flushes the branch count cache' do
        expect(repository).to receive(:expire_branch_count_cache)

        repository.before_delete
      end

830 831 832 833 834 835 836 837 838 839 840
      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
841 842

      it 'flushes the exists cache' do
843
        expect(repository).to receive(:expire_exists_cache).twice
844 845 846

        repository.before_delete
      end
847 848 849 850 851 852 853 854 855 856 857 858 859
    end

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

      it 'flushes the caches that depend on repository data' do
        expect(repository).to receive(:expire_cache)

        repository.before_delete
      end

860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883
      it 'flushes the tags cache' do
        expect(repository).to receive(:expire_tags_cache)

        repository.before_delete
      end

      it 'flushes the tag count cache' do
        expect(repository).to receive(:expire_tag_count_cache)

        repository.before_delete
      end

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

        repository.before_delete
      end

      it 'flushes the branch count cache' do
        expect(repository).to receive(:expire_branch_count_cache)

        repository.before_delete
      end

884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911
      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

912
  describe '#before_push_tag' do
913 914
    it 'flushes the cache' do
      expect(repository).to receive(:expire_cache)
915
      expect(repository).to receive(:expire_tag_count_cache)
916

917
      repository.before_push_tag
918 919 920
    end
  end

921 922 923 924 925 926 927 928 929 930 931 932 933 934
  describe '#before_import' do
    it 'flushes the emptiness cachess' do
      expect(repository).to receive(:expire_emptiness_caches)

      repository.before_import
    end

    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

      repository.before_import
    end
  end

935 936 937 938 939 940
  describe '#after_import' do
    it 'flushes the emptiness cachess' do
      expect(repository).to receive(:expire_emptiness_caches)

      repository.after_import
    end
941 942 943 944 945 946

    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

      repository.after_import
    end
947 948 949 950
  end

  describe '#after_push_commit' do
    it 'flushes the cache' do
951
      expect(repository).to receive(:expire_cache).with('master', '123')
952

953
      repository.after_push_commit('master', '123')
954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
    end
  end

  describe '#after_create_branch' do
    it 'flushes the visible content cache' do
      expect(repository).to receive(:expire_has_visible_content_cache)

      repository.after_create_branch
    end
  end

  describe '#after_remove_branch' do
    it 'flushes the visible content cache' do
      expect(repository).to receive(:expire_has_visible_content_cache)

      repository.after_remove_branch
    end
  end
972

973 974 975 976 977 978
  describe '#after_create' do
    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

      repository.after_create
    end
979 980 981 982 983 984 985 986 987 988 989 990

    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
991 992
  end

993 994 995 996 997 998 999 1000 1001 1002
  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

1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
  describe '#before_remove_tag' do
    it 'flushes the tag cache' do
      expect(repository).to receive(:expire_tag_count_cache)

      repository.before_remove_tag
    end
  end

  describe '#branch_count' do
    it 'returns the number of branches' do
      expect(repository.branch_count).to be_an_instance_of(Fixnum)
    end
  end

  describe '#tag_count' do
    it 'returns the number of tags' do
      expect(repository.tag_count).to be_an_instance_of(Fixnum)
    end
  end

  describe '#expire_branch_count_cache' do
    let(:cache) { repository.send(:cache) }

    it 'expires the cache' do
      expect(cache).to receive(:expire).with(:branch_count)

      repository.expire_branch_count_cache
    end
  end

  describe '#expire_tag_count_cache' do
    let(:cache) { repository.send(:cache) }

    it 'expires the cache' do
      expect(cache).to receive(:expire).with(:tag_count)

      repository.expire_tag_count_cache
    end
  end
1042

1043
  describe '#add_tag' do
1044 1045
    context 'with a valid target' do
      let(:user) { build_stubbed(:user) }
1046

1047 1048 1049 1050 1051 1052
      it 'creates the tag using rugged' do
        expect(repository.rugged.tags).to receive(:create).
          with('8.5', repository.commit('master').id,
            hash_including(message: 'foo',
                           tagger: hash_including(name: user.name, email: user.email))).
          and_call_original
1053

1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
        repository.add_tag(user, '8.5', 'master', 'foo')
      end

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

        expect(tag).to be_a(Gitlab::Git::Tag)
      end
    end

    context 'with an invalid target' do
      it 'returns false' do
        expect(repository.add_tag(user, '8.5', 'bar', 'foo')).to be false
      end
1068 1069 1070
    end
  end

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
  describe '#rm_branch' do
    let(:user) { create(:user) }

    it 'removes a branch' do
      expect(repository).to receive(:before_remove_branch)
      expect(repository).to receive(:after_remove_branch)

      repository.rm_branch(user, 'feature')
    end
  end
1081 1082 1083 1084

  describe '#rm_tag' do
    it 'removes a tag' do
      expect(repository).to receive(:before_remove_tag)
1085
      expect(repository.rugged.tags).to receive(:delete).with('v1.1.0')
1086

1087
      repository.rm_tag('v1.1.0')
1088 1089
    end
  end
1090 1091

  describe '#avatar' do
1092 1093 1094 1095 1096 1097
    it 'returns nil if repo does not exist' do
      expect(repository).to receive(:exists?).and_return(false)

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

1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
    it 'returns the first avatar file found in the repository' do
      expect(repository).to receive(:blob_at_branch).
        with('master', 'logo.png').
        and_return(true)

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

    it 'caches the output' do
      allow(repository).to receive(:blob_at_branch).
        with('master', 'logo.png').
        and_return(true)

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

1113
      expect(repository).not_to receive(:blob_at_branch)
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
      expect(repository.avatar).to eq('logo.png')
    end
  end

  describe '#expire_avatar_cache' do
    let(:cache) { repository.send(:cache) }

    before do
      allow(repository).to receive(:cache).and_return(cache)
    end

    context 'without a branch or revision' do
      it 'flushes the cache' do
        expect(cache).to receive(:expire).with(:avatar)

        repository.expire_avatar_cache
      end
    end

    context 'with a branch' do
      it 'does not flush the cache if the branch is not the default branch' do
        expect(cache).not_to receive(:expire)

        repository.expire_avatar_cache('cats')
      end

      it 'flushes the cache if the branch equals the default branch' do
        expect(cache).to receive(:expire).with(:avatar)

        repository.expire_avatar_cache(repository.root_ref)
      end
    end

    context 'with a branch and revision' do
      let(:commit) { double(:commit) }

      before do
        allow(repository).to receive(:commit).and_return(commit)
      end

      it 'does not flush the cache if the commit does not change any logos' do
        diff = double(:diff, new_path: 'test.txt')

1157
        expect(commit).to receive(:raw_diffs).and_return([diff])
1158 1159 1160 1161 1162 1163 1164 1165
        expect(cache).not_to receive(:expire)

        repository.expire_avatar_cache(repository.root_ref, '123')
      end

      it 'flushes the cache if the commit changes any of the logos' do
        diff = double(:diff, new_path: Repository::AVATAR_FILES[0])

1166
        expect(commit).to receive(:raw_diffs).and_return([diff])
1167 1168 1169 1170 1171 1172
        expect(cache).to receive(:expire).with(:avatar)

        repository.expire_avatar_cache(repository.root_ref, '123')
      end
    end
  end
1173

1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
  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

1184 1185 1186 1187
  describe '#build_cache' do
    let(:cache) { repository.send(:cache) }

    it 'builds the caches if they do not already exist' do
1188 1189
      cache_keys = repository.cache_keys + repository.cache_keys_for_branches_and_tags

1190
      expect(cache).to receive(:exist?).
1191
        exactly(cache_keys.length).
1192 1193 1194
        times.
        and_return(false)

1195
      cache_keys.each do |key|
1196 1197 1198 1199 1200 1201 1202
        expect(repository).to receive(key)
      end

      repository.build_cache
    end

    it 'does not build any caches that already exist' do
1203 1204
      cache_keys = repository.cache_keys + repository.cache_keys_for_branches_and_tags

1205
      expect(cache).to receive(:exist?).
1206
        exactly(cache_keys.length).
1207 1208 1209
        times.
        and_return(true)

1210
      cache_keys.each do |key|
1211
        expect(repository).not_to receive(key)
1212 1213 1214 1215 1216
      end

      repository.build_cache
    end
  end
1217

1218
  describe "#keep_around" do
1219 1220 1221 1222
    it "does not fail if we attempt to reference bad commit" do
      expect(repository.kept_around?('abc1234')).to be_falsey
    end

1223 1224 1225 1226 1227
    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
1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

    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
1244
  end
1245
end