repository_spec.rb 81.3 KB
Newer Older
1 2
# frozen_string_literal: true

3 4
require 'spec_helper'

5
describe Repository do
6
  include RepoHelpers
7 8
  include GitHelpers

9
  TestBlob = Struct.new(:path)
10

11
  let(:project) { create(:project, :repository) }
12
  let(:repository) { project.repository }
13
  let(:broken_repository) { create(:project, :broken_storage).repository }
14
  let(:user) { create(:user) }
15
  let(:git_user) { Gitlab::Git::User.from_gitlab(user) }
16

17
  let(:message) { 'Test message' }
18

Rubén Dávila's avatar
Rubén Dávila committed
19
  let(:merge_commit) do
20
    merge_request = create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project)
21 22 23 24

    merge_commit_id = repository.merge(user,
                                       merge_request.diff_head_sha,
                                       merge_request,
25
                                       message)
26

27
    repository.commit(merge_commit_id)
28
  end
29

30 31
  let(:author_email) { 'user@example.org' }
  let(:author_name) { 'John Doe' }
32

33 34
  def expect_to_raise_storage_error
    expect { yield }.to raise_error do |exception|
35
      storage_exceptions = [Gitlab::Git::CommandError, GRPC::Unavailable]
36 37 38
      known_exception = storage_exceptions.select { |e| exception.is_a?(e) }

      expect(known_exception).not_to be_nil
39 40 41
    end
  end

42
  describe '#branch_names_contains' do
43 44
    set(:project) { create(:project, :repository) }
    let(:repository) { project.repository }
45

46
    subject { repository.branch_names_contains(sample_commit.id) }
47

48 49 50
    it { is_expected.to include('master') }
    it { is_expected.not_to include('feature') }
    it { is_expected.not_to include('fix') }
51

52
    describe 'when storage is broken', :broken_storage do
53
      it 'raises a storage error' do
54 55
        expect_to_raise_storage_error do
          broken_repository.branch_names_contains(sample_commit.id)
56 57 58
        end
      end
    end
59
  end
60

61
  describe '#tag_names_contains' do
62
    subject { repository.tag_names_contains(sample_commit.id) }
63

64 65
    it { is_expected.to include('v1.1.0') }
    it { is_expected.not_to include('v1.0.0') }
66 67
  end

68
  describe 'tags_sorted_by' do
haseeb's avatar
haseeb committed
69 70
    context 'name_desc' do
      subject { repository.tags_sorted_by('name_desc').map(&:name) }
71 72 73 74

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

haseeb's avatar
haseeb committed
75 76 77 78 79 80
    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

81 82 83 84 85 86 87 88 89 90 91
    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)

92 93
          allow(tag_a).to receive(:dereferenced_target).and_return(double_first)
          allow(tag_b).to receive(:dereferenced_target).and_return(double_last)
94
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
95 96 97 98 99 100 101 102 103 104 105 106
        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)

107 108
          allow(tag_a).to receive(:dereferenced_target).and_return(double_last)
          allow(tag_b).to receive(:dereferenced_target).and_return(double_first)
109
          allow(repository).to receive(:tags).and_return([tag_a, tag_b])
110 111 112 113
        end

        it { is_expected.to eq(['v1.1.0', 'v1.0.0']) }
      end
114 115 116 117 118 119 120 121 122

      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' } }
123

124
          rugged_repo(repository).tags.create(annotated_tag_name, 'a48e4fc218069f68ef2e769dd8dfea3991362175', options)
125 126 127 128 129 130 131 132 133 134 135

          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
136
          rugged_repo(repository).tags.delete(annotated_tag_name)
137 138
        end
      end
139 140 141
    end
  end

142
  describe '#ref_name_for_sha' do
143
    it 'returns the ref' do
144 145
      allow(repository.raw_repository).to receive(:ref_name_for_sha)
        .and_return('refs/environments/production/77')
146

147
      expect(repository.ref_name_for_sha('bla', '0' * 40)).to eq 'refs/environments/production/77'
148 149 150
    end
  end

151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
  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

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
  describe '#list_last_commits_for_tree' do
    let(:path_to_commit) do
      {
        "encoding" => "913c66a37b4a45b9769037c55c2d238bd0942d2e",
        "files" => "570e7b2abdd848b95f2f578043fc23bd6f6fd24d",
        ".gitignore" => "c1acaa58bbcbc3eafe538cb8274ba387047b69f8",
        ".gitmodules" => "6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9",
        "CHANGELOG" => "913c66a37b4a45b9769037c55c2d238bd0942d2e",
        "CONTRIBUTING.md" => "6d394385cf567f80a8fd85055db1ab4c5295806f",
        "Gemfile.zip" => "ae73cb07c9eeaf35924a10f713b364d32b2dd34f",
        "LICENSE" => "1a0b36b3cdad1d2ee32457c102a8c0b7056fa863",
        "MAINTENANCE.md" => "913c66a37b4a45b9769037c55c2d238bd0942d2e",
        "PROCESS.md" => "913c66a37b4a45b9769037c55c2d238bd0942d2e",
        "README.md" => "1a0b36b3cdad1d2ee32457c102a8c0b7056fa863",
        "VERSION" => "913c66a37b4a45b9769037c55c2d238bd0942d2e",
        "gitlab-shell" => "6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9",
        "six" => "cfe32cf61b73a0d5e9f13e774abde7ff789b1660"
      }
    end

    subject { repository.list_last_commits_for_tree(sample_commit.id, '.').id }

    it 'returns the last commits for every entry in the current path' do
      result = repository.list_last_commits_for_tree(sample_commit.id, '.')

      result.each do |key, value|
        result[key] = value.id
      end

      expect(result).to include(path_to_commit)
    end

    it 'returns the last commits for every entry in the current path starting from the offset' do
      result = repository.list_last_commits_for_tree(sample_commit.id, '.', offset: path_to_commit.size - 1)

      expect(result.size).to eq(1)
    end

    it 'returns a limited number of last commits for every entry in the current path starting from the offset' do
      result = repository.list_last_commits_for_tree(sample_commit.id, '.', limit: 1)

      expect(result.size).to eq(1)
    end

    it 'returns an empty hash when offset is out of bounds' do
      result = repository.list_last_commits_for_tree(sample_commit.id, '.', offset: path_to_commit.size)

      expect(result.size).to eq(0)
    end
220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238

    context 'with a commit with invalid UTF-8 path' do
      def create_commit_with_invalid_utf8_path
        rugged = rugged_repo(repository)
        blob_id = Rugged::Blob.from_buffer(rugged, "some contents")
        tree_builder = Rugged::Tree::Builder.new(rugged)
        tree_builder.insert({ oid: blob_id, name: "hello\x80world", filemode: 0100644 })
        tree_id = tree_builder.write
        user = { email: "jcai@gitlab.com", time: Time.now, name: "John Cai" }

        Rugged::Commit.create(rugged, message: 'some commit message', parents: [rugged.head.target.oid], tree: tree_id, committer: user, author: user)
      end

      it 'does not raise an error' do
        commit = create_commit_with_invalid_utf8_path

        expect { repository.list_last_commits_for_tree(commit, '.', offset: 0) }.not_to raise_error
      end
    end
239 240
  end

241
  describe '#last_commit_for_path' do
242
    subject { repository.last_commit_for_path(sample_commit.id, '.gitignore').id }
243

244
    it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
245

246
    describe 'when storage is broken', :broken_storage do
247
      it 'raises a storage error' do
248 249
        expect_to_raise_storage_error do
          broken_repository.last_commit_id_for_path(sample_commit.id, '.gitignore')
250 251
        end
      end
252
    end
253
  end
254

Hiroyuki Sato's avatar
Hiroyuki Sato committed
255
  describe '#last_commit_id_for_path' do
256
    subject { repository.last_commit_id_for_path(sample_commit.id, '.gitignore') }
Hiroyuki Sato's avatar
Hiroyuki Sato committed
257

258 259 260
    it "returns last commit id for a given path" do
      is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8')
    end
261

262 263 264
    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')}"
265

266 267 268
      expect(cache).to receive(:fetch).with(key).and_return('c1acaa5')
      is_expected.to eq('c1acaa5')
    end
269

270
    describe 'when storage is broken', :broken_storage do
271
      it 'raises a storage error' do
272 273
        expect_to_raise_storage_error do
          broken_repository.last_commit_for_path(sample_commit.id, '.gitignore').id
274 275
        end
      end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
276
    end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
277 278
  end

279
  describe '#commits' do
Tiago Botelho's avatar
Tiago Botelho committed
280 281 282 283
    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
284 285
    end

Tiago Botelho's avatar
Tiago Botelho committed
286 287 288 289
    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
290

Tiago Botelho's avatar
Tiago Botelho committed
291 292 293 294 295 296 297 298 299 300 301 302 303
      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
304

Tiago Botelho's avatar
Tiago Botelho committed
305 306
        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
307

Tiago Botelho's avatar
Tiago Botelho committed
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
          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
325 326 327
    end
  end

328
  describe '#new_commits' do
329 330
    set(:project) { create(:project, :repository) }
    let(:repository) { project.repository }
331

332
    subject { repository.new_commits(rev) }
333

334 335
    context 'when there are no new commits' do
      let(:rev) { repository.commit.id }
336

337 338
      it 'returns an empty array' do
        expect(subject).to eq([])
339
      end
340
    end
341

342 343 344
    context 'when new commits are found' do
      let(:branch) { 'orphaned-branch' }
      let!(:rev) { repository.commit(branch).id }
345

346 347
      it 'returns the commits' do
        repository.delete_branch(branch)
348

349 350 351
        expect(subject).not_to be_empty
        expect(subject).to all( be_a(::Commit) )
        expect(subject.size).to eq(1)
352 353
      end
    end
354 355
  end

356 357
  describe '#commits_by' do
    set(:project) { create(:project, :repository) }
358
    let(:oids) { TestEnv::BRANCH_SHA.values }
359

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

362 363 364 365
    it 'finds each commit' do
      expect(subject).not_to include(nil)
      expect(subject.size).to eq(oids.size)
    end
366

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

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

376 377 378
      it 'returns only found commits' do
        expect(subject).not_to include(nil)
        expect(subject.size).to eq(10)
379
      end
380
    end
381

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

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

388
        subject
389 390 391 392
      end
    end
  end

393
  describe '#find_commits_by_message' do
394 395
    it 'returns commits with messages containing a given string' do
      commit_ids = repository.find_commits_by_message('submodule').map(&:id)
396

397 398 399 400 401 402
      expect(commit_ids).to include(
        '5937ac0a7beb003549fc5fd26fc247adbce4a52e',
        '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9',
        'cfe32cf61b73a0d5e9f13e774abde7ff789b1660'
      )
      expect(commit_ids).not_to include('913c66a37b4a45b9769037c55c2d238bd0942d2e')
403 404
    end

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

408
      expect(commit_ids).to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
409
    end
410

411
    describe 'when storage is broken', :broken_storage do
412
      it 'raises a storage error' do
413 414 415
        expect_to_raise_storage_error { broken_repository.find_commits_by_message('s') }
      end
    end
416 417
  end

418
  describe '#blob_at' do
419 420 421 422 423
    context 'blank sha' do
      subject { repository.blob_at(Gitlab::Git::BLANK_SHA, '.gitignore') }

      it { is_expected.to be_nil }
    end
424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441

    context 'regular blob' do
      subject { repository.blob_at(repository.head_commit.sha, '.gitignore') }

      it { is_expected.to be_an_instance_of(::Blob) }
    end

    context 'readme blob on HEAD' do
      subject { repository.blob_at(repository.head_commit.sha, 'README.md') }

      it { is_expected.to be_an_instance_of(::ReadmeBlob) }
    end

    context 'readme blob not on HEAD' do
      subject { repository.blob_at(repository.find_branch('feature').target, 'README.md') }

      it { is_expected.to be_an_instance_of(::Blob) }
    end
442
  end
443

444
  describe '#merged_to_root_ref?' do
445
    context 'merged branch without ff' do
446
      subject { repository.merged_to_root_ref?('branch-merged') }
447 448 449

      it { is_expected.to be_truthy }
    end
450

451 452
    # If the HEAD was ff then it will be false
    context 'merged with ff' do
453 454 455 456
      subject { repository.merged_to_root_ref?('improve/awesome') }

      it { is_expected.to be_truthy }
    end
457

458 459 460 461 462
    context 'not merged branch' do
      subject { repository.merged_to_root_ref?('not-merged-branch') }

      it { is_expected.to be_falsey }
    end
463 464 465 466 467 468

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

      it { is_expected.to be_falsey }
    end
469 470 471 472 473 474 475 476 477 478 479 480

    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
481 482
  end

483
  describe '#can_be_merged?' do
484 485
    context 'mergeable branches' do
      subject { repository.can_be_merged?('0b4bc9a49b562e85de7cc9e834518ea6828729b9', 'master') }
486

487 488
      it { is_expected.to be_truthy }
    end
489

490 491
    context 'non-mergeable branches without conflict sides missing' do
      subject { repository.can_be_merged?('bb5206fee213d983da88c47f9cf4cc6caf9c66dc', 'feature') }
492

493 494
      it { is_expected.to be_falsey }
    end
495

496 497
    context 'non-mergeable branches with conflict sides missing' do
      subject { repository.can_be_merged?('conflict-missing-side', 'conflict-start') }
498

499 500
      it { is_expected.to be_falsey }
    end
501

502 503
    context 'submodule changes that confuse rugged' do
      subject { repository.can_be_merged?('update-gitlab-shell-v-6-0-1', 'update-gitlab-shell-v-6-0-3') }
504

505
      it { is_expected.to be_falsey }
506
    end
507 508
  end

509 510 511
  describe '#commit' do
    context 'when ref exists' do
      it 'returns commit object' do
512 513
        expect(repository.commit('master'))
          .to be_an_instance_of Commit
514 515 516 517 518 519 520 521 522
      end
    end

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

523 524 525 526 527 528 529 530
    context 'when ref is not specified' do
      it 'is using a root ref' do
        expect(repository).to receive(:find_commit).with('master')

        repository.commit
      end
    end

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
    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
546
  describe "#create_dir" do
547 548
    it "commits a change that creates a new directory" do
      expect do
549
        repository.create_dir(user, 'newdir',
550
          message: 'Create newdir', branch_name: 'master')
551
      end.to change { repository.count_commits(ref: 'master') }.by(1)
552 553 554 555 556

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

557
    context "when committing to another project" do
558
      let(:forked_project) { create(:project, :repository) }
559 560 561

      it "creates a fork and commit to the forked project" do
        expect do
562
          repository.create_dir(user, 'newdir',
563
            message: 'Create newdir', branch_name: 'patch',
Lin Jen-Shin's avatar
Lin Jen-Shin committed
564
            start_branch_name: 'master', start_project: forked_project)
565
        end.to change { repository.count_commits(ref: 'master') }.by(0)
566 567 568 569 570 571 572 573 574

        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

575 576 577
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
578
          repository.create_dir(user, 'newdir',
579 580 581
            message: 'Add newdir',
            branch_name: 'master',
            author_email: author_email, author_name: author_name)
582
        end.to change { repository.count_commits(ref: 'master') }.by(1)
583 584 585 586 587 588 589 590 591

        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

592 593
  describe "#create_file" do
    it 'commits new file successfully' do
594
      expect do
595 596 597
        repository.create_file(user, 'NEWCHANGELOG', 'Changelog!',
                               message: 'Create changelog',
                               branch_name: 'master')
598
      end.to change { repository.count_commits(ref: 'master') }.by(1)
599

600
      blob = repository.blob_at('master', 'NEWCHANGELOG')
601

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

605
    it 'creates new file and dir when file_path has a forward slash' do
606
      expect do
607 608
        repository.create_file(user, 'new_dir/new_file.txt', 'File!',
                               message: 'Create new_file with new_dir',
609
                               branch_name: 'master')
610
      end.to change { repository.count_commits(ref: 'master') }.by(1)
611

612 613
      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!')
614 615
    end

616
    it 'respects the autocrlf setting' do
617
      repository.create_file(user, 'hello.txt', "Hello,\r\nWorld",
618
                             message: 'Add hello world',
619
                             branch_name: 'master')
620 621 622 623 624 625

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

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

626 627 628
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
629
          repository.create_file(user, 'NEWREADME', 'README!',
630 631 632 633
                                 message: 'Add README',
                                 branch_name: 'master',
                                 author_email: author_email,
                                 author_name: author_name)
634
        end.to change { repository.count_commits(ref: 'master') }.by(1)
635 636 637 638 639 640 641

        last_commit = repository.commit

        expect(last_commit.author_email).to eq(author_email)
        expect(last_commit.author_name).to eq(author_name)
      end
    end
642 643
  end

644
  describe "#update_file" do
645 646 647 648 649
    it 'updates file successfully' do
      expect do
        repository.update_file(user, 'CHANGELOG', 'Changelog!',
                               message: 'Update changelog',
                               branch_name: 'master')
650
      end.to change { repository.count_commits(ref: 'master') }.by(1)
651 652 653 654 655 656

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

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

657
    it 'updates filename successfully' do
658 659
      expect do
        repository.update_file(user, 'NEWLICENSE', 'Copyright!',
660
                                     branch_name: 'master',
661
                                     previous_path: 'LICENSE',
662
                                     message: 'Changes filename')
663
      end.to change { repository.count_commits(ref: 'master') }.by(1)
664 665 666 667 668 669

      files = repository.ls_files('master')

      expect(files).not_to include('LICENSE')
      expect(files).to include('NEWLICENSE')
    end
670 671 672 673

    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
674 675 676 677 678 679
          repository.update_file(user, 'README', 'Updated README!',
                                 branch_name: 'master',
                                 previous_path: 'README',
                                 message: 'Update README',
                                 author_email: author_email,
                                 author_name: author_name)
680
        end.to change { repository.count_commits(ref: 'master') }.by(1)
681 682 683 684 685 686 687 688 689

        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
690
  describe "#delete_file" do
691 692
    it 'removes file successfully' do
      expect do
693
        repository.delete_file(user, 'README',
694
          message: 'Remove README', branch_name: 'master')
695
      end.to change { repository.count_commits(ref: 'master') }.by(1)
696 697 698 699 700 701 702

      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
703
          repository.delete_file(user, 'README',
704 705
            message: 'Remove README', branch_name: 'master',
            author_email: author_email, author_name: author_name)
706
        end.to change { repository.count_commits(ref: 'master') }.by(1)
707 708 709 710 711 712 713 714 715

        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

716
  describe "search_files_by_content" do
717
    let(:results) { repository.search_files_by_content('feature', 'master') }
718 719 720 721
    subject { results }

    it { is_expected.to be_an Array }

722
    it 'regex-escapes the query string' do
723
      results = repository.search_files_by_content("test\\", 'master')
724 725 726 727

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

728
    it 'properly handles an unmatched parenthesis' do
729
      results = repository.search_files_by_content("test(", 'master')
730 731 732 733

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

Valery Sizov's avatar
Valery Sizov committed
734
    it 'properly handles when query is not present' do
735
      results = repository.search_files_by_content('', 'master')
Valery Sizov's avatar
Valery Sizov committed
736 737 738 739 740

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

    it 'properly handles query when repo is empty' do
741
      repository = create(:project, :empty_repo).repository
742
      results = repository.search_files_by_content('test', 'master')
Valery Sizov's avatar
Valery Sizov committed
743 744 745 746

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

747
    describe 'when storage is broken', :broken_storage do
748
      it 'raises a storage error' do
749 750 751 752 753 754
        expect_to_raise_storage_error do
          broken_repository.search_files_by_content('feature', 'master')
        end
      end
    end

755 756 757 758
    describe 'result' do
      subject { results.first }

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

763
  describe "search_files_by_name" do
764 765 766 767 768 769
    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
770 771
    it 'ignores leading slashes' do
      results = repository.search_files_by_name('/files', 'master')
772

773 774 775
      expect(results.first).to eq('files/html/500.html')
    end

776
    it 'properly handles when query is only slashes' do
777
      results = repository.search_files_by_name('//', 'master')
778

779
      expect(results).to match_array([])
780 781
    end

782 783 784 785 786 787 788
    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
789
      repository = create(:project, :empty_repo).repository
790 791 792 793 794

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

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

796
    describe 'when storage is broken', :broken_storage do
797
      it 'raises a storage error' do
798 799 800 801 802
        expect_to_raise_storage_error { broken_repository.search_files_by_name('files', 'master') }
      end
    end
  end

803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
  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

835
  describe '#fetch_ref' do
836
    let(:broken_repository) { create(:project, :broken_storage).repository }
837

838
    describe 'when storage is broken', :broken_storage do
839
      it 'raises a storage error' do
840 841 842
        expect_to_raise_storage_error do
          broken_repository.fetch_ref(broken_repository, source_ref: '1', target_ref: '2')
        end
843 844
      end
    end
845 846
  end

847 848 849 850 851 852 853 854 855 856 857 858 859
  describe '#get_raw_changes' do
    context `with non-UTF8 bytes in paths` do
      let(:old_rev) { 'd0888d297eadcd7a345427915c309413b1231e65' }
      let(:new_rev) { '19950f03c765f7ac8723a73a0599764095f52fc0' }
      let(:changes) { repository.raw_changes_between(old_rev, new_rev) }

      it 'returns the changes' do
        expect { changes }.not_to raise_error
        expect(changes.first.new_path.bytes).to eq("hello\x80world".bytes)
      end
    end
  end

860
  describe '#create_ref' do
861
    it 'redirects the call to write_ref' do
862 863
      ref, ref_path = '1', '2'

864
      expect(repository.raw_repository).to receive(:write_ref).with(ref_path, ref)
865 866 867 868 869

      repository.create_ref(ref, ref_path)
    end
  end

870
  describe "#changelog", :use_clean_rails_memory_store_caching do
871 872 873
    it 'accepts changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changelog')])

874
      expect(repository.changelog.path).to eq('changelog')
875 876 877 878 879
    end

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

880
      expect(repository.changelog.path).to eq('news')
881 882 883 884 885
    end

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

886
      expect(repository.changelog.path).to eq('history')
887 888 889 890 891
    end

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

892
      expect(repository.changelog.path).to eq('changes')
893 894 895 896 897
    end

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

898
      expect(repository.changelog.path).to eq('CHANGELOG')
899 900 901
    end
  end

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

908
    it 'handles when HEAD points to non-existent ref' do
909
      repository.create_file(
910
        user, 'LICENSE', 'Copyright!',
911
        message: 'Add LICENSE', branch_name: 'master')
912

913
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
914 915 916 917

      expect(repository.license_blob).to be_nil
    end

918
    it 'looks in the root_ref only' do
919
      repository.delete_file(user, 'LICENSE',
920
        message: 'Remove LICENSE', branch_name: 'markdown')
921
      repository.create_file(user, 'LICENSE',
922
        Licensee::License.new('mit').content,
923
        message: 'Add LICENSE', branch_name: 'markdown')
924 925 926 927

      expect(repository.license_blob).to be_nil
    end

928
    it 'detects license file with no recognizable open-source license content' do
929 930
      repository.create_file(user, 'LICENSE', 'Copyright!',
        message: 'Add LICENSE', branch_name: 'master')
931

932
      expect(repository.license_blob.path).to eq('LICENSE')
933 934
    end

935 936
    %w[LICENSE LICENCE LiCensE LICENSE.md LICENSE.foo COPYING COPYING.md].each do |filename|
      it "detects '#{filename}'" do
937
        repository.create_file(user, filename,
938
          Licensee::License.new('mit').content,
939
          message: "Add #{filename}", branch_name: 'master')
940

941 942
        expect(repository.license_blob.name).to eq(filename)
      end
943 944 945
    end
  end

946
  describe '#license_key', :use_clean_rails_memory_store_caching do
947
    before do
948
      repository.delete_file(user, 'LICENSE',
949
        message: 'Remove LICENSE', branch_name: 'master')
950
    end
951

952
    it 'returns nil when no license is detected' do
953 954 955
      expect(repository.license_key).to be_nil
    end

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

959 960 961
      expect(repository.license_key).to be_nil
    end

962
    it 'returns nil when the content is not recognizable' do
963
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
964
        message: 'Add LICENSE', branch_name: 'master')
965 966

      expect(repository.license_key).to be_nil
967
    end
968

969 970 971 972 973 974
    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

975
    it 'returns nil when master does not exist' do
976 977
      repository.rm_branch(user, 'master')

978
      expect(repository.license_key).to be_nil
979 980
    end

981
    it 'returns the license key' do
982
      repository.create_file(user, 'LICENSE',
983
        Licensee::License.new('mit').content,
984
        message: 'Add LICENSE', branch_name: 'master')
985

986
      expect(repository.license_key).to eq('mit')
987
    end
988
  end
989

990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
  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
1007
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
        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

1023
  describe "#gitlab_ci_yml", :use_clean_rails_memory_store_caching do
1024 1025 1026 1027
    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)

1028
      expect(repository.gitlab_ci_yml.path).to eq('.gitlab-ci.yml')
1029 1030 1031 1032 1033 1034 1035 1036
    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
1037
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
1038 1039 1040 1041
      expect(repository.gitlab_ci_yml).to be_nil
    end
  end

1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
  describe '#ambiguous_ref?' do
    let(:ref) { 'ref' }

    subject { repository.ambiguous_ref?(ref) }

    context 'when ref is ambiguous' do
      before do
        repository.add_tag(project.creator, ref, 'master')
        repository.add_branch(project.creator, ref, 'master')
      end

1053
      it 'is true' do
1054 1055 1056 1057 1058 1059 1060 1061 1062
        is_expected.to eq(true)
      end
    end

    context 'when ref is not ambiguous' do
      before do
        repository.add_tag(project.creator, ref, 'master')
      end

1063
      it 'is false' do
1064 1065 1066 1067 1068
        is_expected.to eq(false)
      end
    end
  end

1069
  describe '#expand_ref' do
1070 1071
    let(:ref) { 'ref' }

1072
    subject { repository.expand_ref(ref) }
1073

1074
    context 'when ref is not tag or branch name' do
1075 1076
      let(:ref) { 'refs/heads/master' }

1077 1078
      it 'returns nil' do
        is_expected.to eq(nil)
1079 1080 1081
      end
    end

1082 1083 1084
    context 'when ref is tag name' do
      before do
        repository.add_tag(project.creator, ref, 'master')
1085 1086
      end

1087 1088
      it 'returns the tag ref' do
        is_expected.to eq("refs/tags/#{ref}")
1089
      end
1090
    end
1091

1092 1093 1094 1095
    context 'when ref is branch name' do
      before do
        repository.add_branch(project.creator, ref, 'master')
      end
1096

1097 1098
      it 'returns the branch ref' do
        is_expected.to eq("refs/heads/#{ref}")
1099 1100 1101 1102
      end
    end
  end

1103
  describe '#add_branch' do
1104 1105
    let(:branch_name) { 'new_feature' }
    let(:target) { 'master' }
1106

1107
    subject { repository.add_branch(user, branch_name, target) }
1108

1109 1110 1111 1112
    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)
1113

1114
      subject
1115 1116
    end

1117 1118 1119 1120
    it 'creates_the_branch' do
      expect(subject.name).to eq(branch_name)
      expect(repository.find_branch(branch_name)).not_to be_nil
    end
1121

1122 1123
    context 'with a non-existing target' do
      let(:target) { 'fake-target' }
1124

1125 1126 1127
      it "returns false and doesn't create the branch" do
        expect(subject).to be(false)
        expect(repository.find_branch(branch_name)).to be_nil
1128 1129 1130 1131
      end
    end
  end

1132
  shared_examples 'asymmetric cached method' do |method|
1133 1134 1135 1136 1137 1138
    context 'asymmetric caching', :use_clean_rails_memory_store_caching, :request_store do
      let(:cache) { repository.send(:cache) }
      let(:request_store_cache) { repository.send(:request_store_cache) }

      context 'when it returns true' do
        before do
1139
          expect(repository.raw_repository).to receive(method).once.and_return(true)
1140 1141 1142 1143
        end

        it 'caches the output in RequestStore' do
          expect do
1144 1145
            repository.send(method)
          end.to change { request_store_cache.read(method) }.from(nil).to(true)
1146 1147 1148 1149
        end

        it 'caches the output in RepositoryCache' do
          expect do
1150 1151
            repository.send(method)
          end.to change { cache.read(method) }.from(nil).to(true)
1152 1153 1154 1155 1156
        end
      end

      context 'when it returns false' do
        before do
1157
          expect(repository.raw_repository).to receive(method).once.and_return(false)
1158 1159 1160 1161
        end

        it 'caches the output in RequestStore' do
          expect do
1162 1163
            repository.send(method)
          end.to change { request_store_cache.read(method) }.from(nil).to(false)
1164 1165 1166 1167
        end

        it 'does NOT cache the output in RepositoryCache' do
          expect do
1168 1169
            repository.send(method)
          end.not_to change { cache.read(method) }.from(nil)
1170 1171 1172
        end
      end
    end
1173
  end
1174

1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186
  describe '#exists?' do
    it 'returns true when a repository exists' do
      expect(repository.exists?).to be(true)
    end

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

      expect(repository.exists?).to be(false)
    end

    context 'with broken storage', :broken_storage do
1187
      it 'raises a storage error' do
1188 1189 1190 1191 1192 1193 1194
        expect_to_raise_storage_error { broken_repository.exists? }
      end
    end

    it_behaves_like 'asymmetric cached method', :exists?
  end

1195
  describe '#has_visible_content?' do
1196 1197 1198 1199 1200 1201 1202
    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
1203

1204 1205
    context 'when true' do
      let(:result) { true }
1206

1207 1208 1209 1210 1211
      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
1212 1213
    end

1214 1215
    context 'when false' do
      let(:result) { false }
1216

1217 1218 1219 1220
      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)
1221 1222 1223 1224
      end
    end
  end

1225 1226 1227 1228 1229 1230 1231 1232 1233
  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

1234 1235 1236 1237 1238 1239 1240 1241 1242
  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

1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258
  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

1259 1260 1261 1262
  describe '#empty?' do
    let(:empty_repository) { create(:project_empty_repo).repository }

    it 'returns true for an empty repository' do
1263
      expect(empty_repository).to be_empty
1264 1265 1266
    end

    it 'returns false for a non-empty repository' do
1267
      expect(repository).not_to be_empty
1268 1269 1270
    end

    it 'caches the output' do
1271
      expect(repository.raw_repository).to receive(:has_visible_content?).once
1272 1273 1274 1275 1276 1277

      repository.empty?
      repository.empty?
    end
  end

1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
  describe '#blobs_at' do
    let(:empty_repository) { create(:project_empty_repo).repository }

    it 'returns empty array for an empty repository' do
      # rubocop:disable Style/WordArray
      expect(empty_repository.blobs_at(['master', 'foobar'])).to eq([])
      # rubocop:enable Style/WordArray
    end

    it 'returns blob array for a non-empty repository' do
      repository.create_file(User.last, 'foobar', 'CONTENT', message: 'message', branch_name: 'master')

      # rubocop:disable Style/WordArray
      blobs = repository.blobs_at([['master', 'foobar']])
      # rubocop:enable Style/WordArray

      expect(blobs.first.name).to eq('foobar')
      expect(blobs.size).to eq(1)
    end
  end

1299 1300 1301 1302 1303 1304
  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
1305 1306 1307
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('master')
1308 1309 1310 1311

      repository.root_ref
      repository.root_ref
    end
1312 1313

    it_behaves_like 'asymmetric cached method', :root_ref
1314 1315 1316 1317 1318 1319
  end

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

1320 1321 1322
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('foo')
1323 1324 1325 1326 1327 1328 1329

      repository.expire_root_ref_cache

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

1330
  describe '#expire_branch_cache' do
1331 1332 1333 1334 1335
    # 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
1336 1337 1338
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1339 1340 1341 1342 1343

      repository.expire_branch_cache
    end

    it 'expires the cache for all branches when the root branch is given' do
1344 1345 1346
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1347 1348 1349 1350 1351

      repository.expire_branch_cache(repository.root_ref)
    end

    it 'expires the cache for a specific branch' do
1352
      expect(cache).to receive(:expire).twice
1353 1354 1355 1356

      repository.expire_branch_cache('foo')
    end
  end
1357

1358 1359 1360
  describe '#expire_emptiness_caches' do
    let(:cache) { repository.send(:cache) }

1361 1362 1363
    it 'expires the caches for an empty repository' do
      allow(repository).to receive(:empty?).and_return(true)

1364
      expect(cache).to receive(:expire).with(:has_visible_content?)
1365 1366 1367

      repository.expire_emptiness_caches
    end
1368 1369 1370 1371

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

1372
      expect(cache).not_to receive(:expire).with(:has_visible_content?)
1373 1374 1375

      repository.expire_emptiness_caches
    end
1376 1377 1378 1379 1380 1381

    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
1382 1383
  end

1384
  describe 'skip_merges option' do
1385
    subject { repository.commits(Gitlab::Git::BRANCH_REF_PREFIX + "'test'", limit: 100, skip_merges: true).map { |k| k.id } }
1386 1387 1388

    it { is_expected.not_to include('e56497bb5f03a90a51293fc6d516788730953899') }
  end
1389 1390

  describe '#merge' do
1391
    let(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project) }
1392
    let(:message) { 'Test \r\n\r\n message' }
1393

1394 1395 1396 1397
    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
1398

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

1402
      expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
1403
    end
1404

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

1408
      expect(repository.commit(merge_commit_id).message).to eq(message.delete("\r"))
1409 1410
    end

1411 1412
    def merge(repository, user, merge_request, message)
      repository.merge(user, merge_request.diff_head_sha, merge_request, message)
1413
    end
1414 1415
  end

1416 1417 1418 1419 1420 1421 1422
  describe '#merge_to_ref' do
    let(:merge_request) do
      create(:merge_request, source_branch: 'feature',
                             target_branch: 'master',
                             source_project: project)
    end

1423
    it 'writes merge of source SHA and first parent ref to MR merge_ref_path' do
1424 1425 1426 1427
      merge_commit_id = repository.merge_to_ref(user,
                                                merge_request.diff_head_sha,
                                                merge_request,
                                                merge_request.merge_ref_path,
1428 1429
                                                'Custom message',
                                                merge_request.target_branch_ref)
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439

      merge_commit = repository.commit(merge_commit_id)

      expect(merge_commit.message).to eq('Custom message')
      expect(merge_commit.author_name).to eq(user.name)
      expect(merge_commit.author_email).to eq(user.commit_email)
      expect(repository.blob_at(merge_commit.id, 'files/ruby/feature.rb')).to be_present
    end
  end

1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
  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

1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 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 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
  describe '#rebase' do
    let(:merge_request) { create(:merge_request, source_branch: 'feature', target_branch: 'master', source_project: project) }

    shared_examples_for 'a method that can rebase successfully' do
      it 'returns the rebase commit sha' do
        rebase_commit_sha = repository.rebase(user, merge_request)
        head_sha = merge_request.source_project.repository.commit(merge_request.source_branch).sha

        expect(rebase_commit_sha).to eq(head_sha)
      end

      it 'sets the `rebase_commit_sha` for the given merge request' do
        rebase_commit_sha = repository.rebase(user, merge_request)

        expect(rebase_commit_sha).not_to be_nil
        expect(merge_request.rebase_commit_sha).to eq(rebase_commit_sha)
      end
    end

    context 'when two_step_rebase feature is enabled' do
      before do
        stub_feature_flags(two_step_rebase: true)
      end

      it_behaves_like 'a method that can rebase successfully'

      it 'executes the new Gitaly RPC' do
        expect_any_instance_of(Gitlab::GitalyClient::OperationService).to receive(:rebase)
        expect_any_instance_of(Gitlab::GitalyClient::OperationService).not_to receive(:user_rebase)

        repository.rebase(user, merge_request)
      end

      describe 'rolling back the `rebase_commit_sha`' do
        let(:new_sha) { Digest::SHA1.hexdigest('foo') }

        it 'does not rollback when there are no errors' do
          second_response = double(pre_receive_error: nil, git_error: nil)
          mock_gitaly(second_response)

          repository.rebase(user, merge_request)

          expect(merge_request.reload.rebase_commit_sha).to eq(new_sha)
        end

        it 'does rollback when an error is encountered in the second step' do
          second_response = double(pre_receive_error: 'my_error', git_error: nil)
          mock_gitaly(second_response)

          expect do
            repository.rebase(user, merge_request)
          end.to raise_error(Gitlab::Git::PreReceiveError)

          expect(merge_request.reload.rebase_commit_sha).to be_nil
        end

        def mock_gitaly(second_response)
          responses = [
            double(rebase_sha: new_sha).as_null_object,
            second_response
          ]

          expect_any_instance_of(
            Gitaly::OperationService::Stub
          ).to receive(:user_rebase_confirmable).and_return(responses.each)
        end
      end
    end

    context 'when two_step_rebase feature is disabled' do
      before do
        stub_feature_flags(two_step_rebase: false)
      end

      it_behaves_like 'a method that can rebase successfully'

      it 'executes the deprecated Gitaly RPC' do
        expect_any_instance_of(Gitlab::GitalyClient::OperationService).to receive(:user_rebase)
        expect_any_instance_of(Gitlab::GitalyClient::OperationService).not_to receive(:rebase)

        repository.rebase(user, merge_request)
      end
    end
  end

1553
  describe '#revert' do
1554 1555 1556
    let(:new_image_commit) { repository.commit('33f3729a45c02fc67d00adb1b8bca394b0e761d9') }
    let(:update_image_commit) { repository.commit('2f63565e7aac07bcdadb654e253078b727143ec4') }
    let(:message) { 'revert message' }
1557

1558 1559 1560
    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)
1561
      end
1562
    end
1563

1564 1565 1566
    context 'when commit was already reverted' do
      it 'raises an error' do
        repository.revert(user, update_image_commit, 'master', message)
1567

1568
        expect { repository.revert(user, update_image_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
1569
      end
1570
    end
1571

1572 1573 1574 1575
    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
1576 1577
    end

1578 1579 1580 1581 1582 1583 1584 1585
    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
1586
    end
1587
  end
1588

1589
  describe '#cherry_pick' do
1590 1591 1592 1593 1594 1595 1596 1597
    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)
1598
      end
1599
    end
1600

1601 1602 1603
    context 'when commit was already cherry-picked' do
      it 'raises an error' do
        repository.cherry_pick(user, pickable_commit, 'master', message)
1604

1605
        expect { repository.cherry_pick(user, pickable_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
1606
      end
1607
    end
1608

1609 1610 1611
    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
1612
      end
1613
    end
1614

1615 1616 1617
    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
1618

1619 1620
        cherry_pick_commit_sha = repository.cherry_pick(user, pickable_merge, 'improve/awesome', message)
        cherry_pick_commit_message = project.commit(cherry_pick_commit_sha).message
1621

1622 1623
        expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).not_to be_nil
        expect(cherry_pick_commit_message).to eq(message)
1624 1625 1626 1627
      end
    end
  end

1628 1629 1630 1631 1632 1633 1634
  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
1635
        expect(repository).not_to receive(:expire_cache)
1636 1637 1638 1639

        repository.before_delete
      end

1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
      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

1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
      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
1663 1664

      it 'flushes the exists cache' do
1665
        expect(repository).to receive(:expire_exists_cache).twice
1666 1667 1668

        repository.before_delete
      end
1669 1670 1671 1672 1673 1674 1675
    end

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

1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687
      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

1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
      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

1716
  describe '#after_change_head' do
1717
    it 'flushes the method caches' do
1718
      expect(repository).to receive(:expire_method_caches).with([
1719 1720 1721
        :size,
        :commit_count,
        :rendered_readme,
1722
        :readme_path,
1723
        :contribution_guide,
1724
        :changelog,
1725 1726
        :license_blob,
        :license_key,
1727
        :gitignore,
1728 1729 1730 1731 1732
        :gitlab_ci_yml,
        :branch_names,
        :tag_names,
        :branch_count,
        :tag_count,
1733
        :avatar,
1734 1735 1736 1737 1738
        :exists?,
        :root_ref,
        :has_visible_content?,
        :issue_template_names,
        :merge_request_template_names,
1739
        :metrics_dashboard_paths,
Rémy Coutable's avatar
Rémy Coutable committed
1740
        :xcode_project?
1741 1742 1743 1744 1745 1746
      ])

      repository.after_change_head
    end
  end

1747
  describe '#expires_caches_for_tags' do
1748
    it 'flushes the cache' do
1749 1750 1751
      expect(repository).to receive(:expire_statistics_caches)
      expect(repository).to receive(:expire_emptiness_caches)
      expect(repository).to receive(:expire_tags_cache)
1752

1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
      repository.expire_caches_for_tags
    end
  end

  describe '#before_push_tag' do
    it 'logs an event' do
      expect(repository).not_to receive(:expire_statistics_caches)
      expect(repository).not_to receive(:expire_emptiness_caches)
      expect(repository).not_to receive(:expire_tags_cache)
      expect(repository).to receive(:repository_event).with(:push_tag)

1764
      repository.before_push_tag
1765 1766 1767 1768
    end
  end

  describe '#after_import' do
1769 1770
    it 'flushes and builds the cache' do
      expect(repository).to receive(:expire_content_cache)
1771 1772 1773

      repository.after_import
    end
1774 1775 1776
  end

  describe '#after_push_commit' do
1777
    it 'expires statistics caches' do
1778 1779
      expect(repository).to receive(:expire_statistics_caches)
        .and_call_original
1780

1781 1782 1783
      expect(repository).to receive(:expire_branch_cache)
        .with('master')
        .and_call_original
1784

1785
      repository.after_push_commit('master')
1786 1787 1788 1789
    end
  end

  describe '#after_create_branch' do
1790
    it 'expires the branch caches' do
1791
      expect(repository).to receive(:expire_branches_cache)
1792 1793 1794

      repository.after_create_branch
    end
1795 1796 1797 1798 1799 1800

    it 'does not expire the branch caches when specified' do
      expect(repository).not_to receive(:expire_branches_cache)

      repository.after_create_branch(expire_cache: false)
    end
1801 1802 1803
  end

  describe '#after_remove_branch' do
1804
    it 'expires the branch caches' do
1805
      expect(repository).to receive(:expire_branches_cache)
1806 1807 1808

      repository.after_remove_branch
    end
1809 1810 1811 1812 1813 1814

    it 'does not expire the branch caches when specified' do
      expect(repository).not_to receive(:expire_branches_cache)

      repository.after_remove_branch(expire_cache: false)
    end
1815
  end
1816

1817
  describe '#after_create' do
1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
    it 'calls expire_status_cache' do
      expect(repository).to receive(:expire_status_cache)

      repository.after_create
    end

    it 'logs an event' do
      expect(repository).to receive(:repository_event).with(:create_repository)

      repository.after_create
    end
  end

  describe '#expire_status_cache' do
1832 1833 1834
    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

1835
      repository.expire_status_cache
1836
    end
1837 1838 1839 1840

    it 'flushes the root ref cache' do
      expect(repository).to receive(:expire_root_ref_cache)

1841
      repository.expire_status_cache
1842 1843 1844 1845 1846
    end

    it 'flushes the emptiness caches' do
      expect(repository).to receive(:expire_emptiness_caches)

1847
      repository.expire_status_cache
1848
    end
1849 1850
  end

1851 1852 1853 1854 1855 1856 1857 1858 1859 1860
  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

1861 1862
  describe '#before_remove_tag' do
    it 'flushes the tag cache' do
1863 1864
      expect(repository).to receive(:expire_tags_cache).and_call_original
      expect(repository).to receive(:expire_statistics_caches).and_call_original
1865 1866 1867 1868 1869 1870 1871

      repository.before_remove_tag
    end
  end

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

1874
      rugged_count = rugged_repo(repository).branches.count
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1875

1876
      expect(repository.branch_count).to eq(rugged_count)
1877 1878 1879 1880 1881
    end
  end

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

1884
      rugged_count = rugged_repo(repository).tags.count
Kim "BKC" Carlbäcker's avatar
Kim "BKC" Carlbäcker committed
1885

1886
      expect(repository.tag_count).to eq(rugged_count)
1887 1888 1889
    end
  end

1890
  describe '#expire_branches_cache' do
1891
    it 'expires the cache' do
1892
      expect(repository).to receive(:expire_method_caches)
1893
        .with(%i(branch_names branch_count has_visible_content?))
1894
        .and_call_original
1895

1896
      repository.expire_branches_cache
1897 1898 1899
    end
  end

1900
  describe '#expire_tags_cache' do
1901
    it 'expires the cache' do
1902 1903 1904
      expect(repository).to receive(:expire_method_caches)
        .with(%i(tag_names tag_count))
        .and_call_original
1905

1906
      repository.expire_tags_cache
1907 1908
    end
  end
1909

1910
  describe '#add_tag' do
1911
    let(:user) { build_stubbed(:user) }
1912

1913 1914 1915
    context 'with a valid target' do
      it 'creates the tag' do
        repository.add_tag(user, '8.5', 'master', 'foo')
1916

1917 1918 1919 1920
        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)
1921
      end
1922

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

1926 1927 1928
        expect(tag).to be_a(Gitlab::Git::Tag)
      end
    end
1929

1930 1931 1932
    context 'with an invalid target' do
      it 'returns false' do
        expect(repository.add_tag(user, '8.5', 'bar', 'foo')).to be false
1933
      end
1934 1935 1936
    end
  end

1937
  describe '#rm_branch' do
1938 1939 1940
    it 'removes a branch' do
      expect(repository).to receive(:before_remove_branch)
      expect(repository).to receive(:after_remove_branch)
1941

1942
      repository.rm_branch(user, 'feature')
1943
    end
1944

1945 1946 1947 1948
    context 'when pre hooks failed' do
      before do
        allow_any_instance_of(Gitlab::GitalyClient::OperationService)
          .to receive(:user_delete_branch).and_raise(Gitlab::Git::PreReceiveError)
1949 1950
      end

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

1956
        expect(repository.find_branch('feature')).not_to be_nil
1957
      end
1958 1959
    end
  end
1960 1961

  describe '#rm_tag' do
1962 1963
    it 'removes a tag' do
      expect(repository).to receive(:before_remove_tag)
1964

1965
      repository.rm_tag(build_stubbed(:user), 'v1.1.0')
1966

1967
      expect(repository.find_tag('v1.1.0')).to be_nil
1968 1969
    end
  end
1970 1971

  describe '#avatar' do
1972
    it 'returns nil if repo does not exist' do
1973
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
1974 1975 1976 1977

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

1978
    it 'returns the first avatar file found in the repository' do
1979 1980 1981
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .and_return(double(:tree, path: 'logo.png'))
1982 1983 1984 1985 1986

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

    it 'caches the output' do
1987 1988 1989 1990
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .once
        .and_return(double(:tree, path: 'logo.png'))
1991

1992
      2.times { expect(repository.avatar).to eq('logo.png') }
1993 1994
    end
  end
1995

1996 1997
  describe '#expire_exists_cache' do
    let(:cache) { repository.send(:cache) }
1998
    let(:request_store_cache) { repository.send(:request_store_cache) }
1999 2000 2001 2002 2003 2004

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

      repository.expire_exists_cache
    end
2005 2006 2007 2008 2009 2010

    it 'expires the request store cache', :request_store do
      expect(request_store_cache).to receive(:expire).with(:exists?)

      repository.expire_exists_cache
    end
2011 2012
  end

2013 2014
  describe '#xcode_project?' do
    before do
2015
      allow(repository).to receive(:tree).with(:head).and_return(double(:tree, trees: [tree]))
2016 2017
    end

2018 2019
    context 'when the root contains a *.xcodeproj directory' do
      let(:tree) { double(:tree, path: 'Foo.xcodeproj') }
2020 2021 2022 2023 2024 2025

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

2026 2027
    context 'when the root contains a *.xcworkspace directory' do
      let(:tree) { double(:tree, path: 'Foo.xcworkspace') }
2028 2029 2030 2031 2032 2033

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

2034 2035
    context 'when the root contains no Xcode config directory' do
      let(:tree) { double(:tree, path: 'Foo') }
2036 2037 2038 2039 2040 2041 2042

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

2043
  describe "#keep_around" do
2044 2045 2046 2047
    it "does not fail if we attempt to reference bad commit" do
      expect(repository.kept_around?('abc1234')).to be_falsey
    end

2048 2049 2050 2051 2052
    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
2053 2054 2055 2056

    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)
2057 2058 2059 2060

      path = Gitlab::GitalyClient::StorageSettings.allow_disk_access do
        File.join(repository.path, ref)
      end
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071
      # 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
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089

    context 'for multiple SHAs' do
      it 'skips non-existent SHAs' do
        repository.keep_around('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', sample_commit.id)

        expect(repository.kept_around?(sample_commit.id)).to be_truthy
      end

      it 'skips already-kept-around SHAs' do
        repository.keep_around(sample_commit.id)

        expect(repository.raw_repository).to receive(:write_ref).exactly(1).and_call_original

        repository.keep_around(sample_commit.id, another_sample_commit.id)

        expect(repository.kept_around?(another_sample_commit.id)).to be_truthy
      end
    end
2090
  end
2091

2092
  describe '#contribution_guide', :use_clean_rails_memory_store_caching do
2093
    it 'returns and caches the output' do
2094 2095 2096 2097
      expect(repository).to receive(:file_on_head)
        .with(:contributing)
        .and_return(Gitlab::Git::Tree.new(path: 'CONTRIBUTING.md'))
        .once
2098 2099

      2.times do
2100 2101
        expect(repository.contribution_guide)
          .to be_an_instance_of(Gitlab::Git::Tree)
2102 2103 2104 2105
      end
    end
  end

2106
  describe '#gitignore', :use_clean_rails_memory_store_caching do
2107
    it 'returns and caches the output' do
2108 2109 2110 2111
      expect(repository).to receive(:file_on_head)
        .with(:gitignore)
        .and_return(Gitlab::Git::Tree.new(path: '.gitignore'))
        .once
2112 2113

      2.times do
2114
        expect(repository.gitignore).to be_an_instance_of(Gitlab::Git::Tree)
2115 2116 2117 2118
      end
    end
  end

2119
  describe '#readme', :use_clean_rails_memory_store_caching do
2120
    context 'with a non-existing repository' do
2121
      let(:project) { create(:project) }
2122

2123
      it 'returns nil' do
2124 2125 2126
        expect(repository.readme).to be_nil
      end
    end
2127

2128
    context 'with an existing repository' do
2129
      context 'when no README exists' do
2130
        let(:project) { create(:project, :empty_repo) }
2131

2132
        it 'returns nil' do
2133 2134 2135 2136 2137
          expect(repository.readme).to be_nil
        end
      end

      context 'when a README exists' do
2138 2139
        let(:project) { create(:project, :repository) }

2140 2141 2142
        it 'returns the README' do
          expect(repository.readme).to be_an_instance_of(ReadmeBlob)
        end
2143 2144 2145 2146
      end
    end
  end

2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
  describe '#readme_path', :use_clean_rails_memory_store_caching do
    context 'with a non-existing repository' do
      let(:project) { create(:project) }

      it 'returns nil' do
        expect(repository.readme_path).to be_nil
      end
    end

    context 'with an existing repository' do
      context 'when no README exists' do
        let(:project) { create(:project, :empty_repo) }

        it 'returns nil' do
          expect(repository.readme_path).to be_nil
        end
      end

      context 'when a README exists' do
        let(:project) { create(:project, :repository) }

        it 'returns the README' do
          expect(repository.readme_path).to eq("README.md")
        end

        it 'caches the response' do
          expect(repository).to receive(:readme).and_call_original.once

          2.times do
            expect(repository.readme_path).to eq("README.md")
          end
        end
      end
    end
  end

2183 2184
  describe '#expire_statistics_caches' do
    it 'expires the caches' do
2185 2186
      expect(repository).to receive(:expire_method_caches)
        .with(%i(size commit_count))
2187

2188 2189 2190 2191 2192 2193
      repository.expire_statistics_caches
    end
  end

  describe '#expire_all_method_caches' do
    it 'expires the caches of all methods' do
2194 2195
      expect(repository).to receive(:expire_method_caches)
        .with(Repository::CACHED_METHODS)
2196 2197 2198

      repository.expire_all_method_caches
    end
2199 2200 2201 2202 2203 2204 2205

    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

2206
      expect(Repository::CACHED_METHODS + Repository::MEMOIZED_CACHED_METHODS).to include(*methods)
2207
    end
2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
  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
2229 2230
        expect(repository.file_on_head(:readme))
          .to be_an_instance_of(Gitlab::Git::Tree)
2231 2232 2233 2234
      end
    end
  end

2235 2236 2237 2238 2239 2240
  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
2241

2242 2243 2244 2245 2246
    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
2247 2248 2249 2250
      end
    end
  end

2251 2252 2253 2254 2255
  describe '#tree' do
    context 'using a non-existing repository' do
      before do
        allow(repository).to receive(:head_commit).and_return(nil)
      end
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 2287 2288
      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

2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
  describe '#local_branches' do
    it 'returns the local branches' do
      masterrev = repository.find_branch('master').dereferenced_target
      create_remote_branch('joe', 'remote_branch', masterrev)
      repository.add_branch(user, 'local_branch', masterrev.id)

      expect(repository.local_branches.any? { |branch| branch.name == 'remote_branch' }).to eq(false)
      expect(repository.local_branches.any? { |branch| branch.name == 'local_branch' }).to eq(true)
    end
  end

2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
  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
2311
        expect(repository.commit_count).to be_an(Integer)
2312 2313 2314 2315
      end
    end
  end

2316
  describe '#commit_count_for_ref' do
2317
    let(:project) { create :project }
2318

2319 2320
    context 'with a non-existing repository' do
      it 'returns 0' do
2321 2322 2323 2324 2325 2326 2327 2328
        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)
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
      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

2339 2340
  describe '#refresh_method_caches' do
    it 'refreshes the caches of the given types' do
2341
      expect(repository).to receive(:expire_method_caches)
2342
        .with(%i(rendered_readme readme_path license_blob license_key license))
2343

2344
      expect(repository).to receive(:rendered_readme)
2345
      expect(repository).to receive(:readme_path)
2346 2347
      expect(repository).to receive(:license_blob)
      expect(repository).to receive(:license_key)
2348
      expect(repository).to receive(:license)
2349 2350 2351

      repository.refresh_method_caches(%i(readme license))
    end
2352
  end
Douwe Maan's avatar
Douwe Maan committed
2353 2354 2355

  describe '#gitlab_ci_yml_for' do
    before do
2356
      repository.create_file(User.last, '.gitlab-ci.yml', 'CONTENT', message: 'Add .gitlab-ci.yml', branch_name: 'master')
Douwe Maan's avatar
Douwe Maan committed
2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373
    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
2374
      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
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
    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
2389

2390
  def create_remote_branch(remote_name, branch_name, target)
2391
    rugged = rugged_repo(repository)
2392 2393 2394
    rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", target.id)
  end

2395
  shared_examples '#ancestor?' do
2396 2397
    let(:commit) { repository.commit }
    let(:ancestor) { commit.parents.first }
2398

2399
    it 'is an ancestor' do
2400 2401
      expect(repository.ancestor?(ancestor.id, commit.id)).to eq(true)
    end
2402

2403
    it 'is not an ancestor' do
2404
      expect(repository.ancestor?(commit.id, ancestor.id)).to eq(false)
2405
    end
2406

2407 2408 2409 2410
    it 'returns false on nil-values' do
      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)
2411
    end
2412

2413 2414 2415
    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)
2416 2417
    end
  end
2418

2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
  describe '#ancestor? with Gitaly enabled' do
    it_behaves_like "#ancestor?"
  end

  describe '#ancestor? with Rugged enabled', :enable_rugged do
    it 'calls out to the Rugged implementation' do
      allow_any_instance_of(Rugged).to receive(:merge_base).with(repository.commit.id, Gitlab::Git::BLANK_SHA).and_call_original

      repository.ancestor?(repository.commit.id, Gitlab::Git::BLANK_SHA)
    end

    it_behaves_like '#ancestor?'
  end

2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
  describe '#archive_metadata' do
    let(:ref) { 'master' }
    let(:storage_path) { '/tmp' }

    let(:prefix) { [project.path, ref].join('-') }
    let(:filename) { prefix + '.tar.gz' }

    subject(:result) { repository.archive_metadata(ref, storage_path, append_sha: false) }

    context 'with hashed storage disabled' do
      let(:project) { create(:project, :repository, :legacy_storage) }

      it 'uses the project path to generate the filename' do
        expect(result['ArchivePrefix']).to eq(prefix)
        expect(File.basename(result['ArchivePath'])).to eq(filename)
      end
    end

    context 'with hashed storage enabled' do
      it 'uses the project path to generate the filename' do
        expect(result['ArchivePrefix']).to eq(prefix)
        expect(File.basename(result['ArchivePath'])).to eq(filename)
      end
    end
  end

2459 2460 2461 2462 2463 2464 2465
  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

2466
      expect(Gitlab::Git::Commit).to receive(:find).once
2467

2468
      2.times { project.commit_by(oid: oid) }
2469 2470 2471 2472 2473
    end

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

2474
      2.times { project.commit_by(oid: '1' * 40) }
2475 2476
    end
  end
2477 2478 2479 2480 2481 2482 2483 2484

  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}")
2485
      expect(subject.gl_project_path).to eq(project.full_path)
2486 2487 2488 2489 2490 2491 2492 2493 2494
    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}")
2495
        expect(subject.gl_project_path).to eq(project.full_path)
2496 2497 2498
      end
    end
  end
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 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605

  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
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616

  describe '#merge_base' do
    set(:project) { create(:project, :repository) }
    subject(:repository) { project.repository }

    it 'only makes one gitaly call' do
      expect(Gitlab::GitalyClient).to receive(:call).once.and_call_original

      repository.merge_base('master', 'fix')
    end
  end
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681

  describe '#create_if_not_exists' do
    let(:project) { create(:project) }
    let(:repository) { project.repository }

    it 'creates the repository if it did not exist' do
      expect { repository.create_if_not_exists }.to change { repository.exists? }.from(false).to(true)
    end

    it 'calls out to the repository client to create a repo' do
      expect(repository.raw.gitaly_repository_client).to receive(:create_repository)

      repository.create_if_not_exists
    end

    context 'it does nothing if the repository already existed' do
      let(:project) { create(:project, :repository) }

      it 'does nothing if the repository already existed' do
        expect(repository.raw.gitaly_repository_client).not_to receive(:create_repository)

        repository.create_if_not_exists
      end
    end

    context 'when the repository exists but the cache is not up to date' do
      let(:project) { create(:project, :repository) }

      it 'does not raise errors' do
        allow(repository).to receive(:exists?).and_return(false)
        expect(repository.raw).to receive(:create_repository).and_call_original

        expect { repository.create_if_not_exists }.not_to raise_error
      end
    end
  end

  describe "#blobs_metadata" do
    set(:project) { create(:project, :repository) }
    let(:repository) { project.repository }

    def expect_metadata_blob(thing)
      expect(thing).to be_a(Blob)
      expect(thing.data).to be_empty
    end

    it "returns blob metadata in batch for HEAD" do
      result = repository.blobs_metadata(["bar/branch-test.txt", "README.md", "does/not/exist"])

      expect_metadata_blob(result.first)
      expect_metadata_blob(result.second)
      expect(result.size).to eq(2)
    end

    it "returns blob metadata for a specified ref" do
      result = repository.blobs_metadata(["files/ruby/feature.rb"], "feature")

      expect_metadata_blob(result.first)
    end

    it "performs a single gitaly call", :request_store do
      expect { repository.blobs_metadata(["bar/branch-test.txt", "readme.txt", "does/not/exist"]) }
        .to change { Gitlab::GitalyClient.get_request_count }.by(1)
    end
  end
2682
end