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

3
describe Repository do
4
  include RepoHelpers
5 6
  include GitHelpers

7
  TestBlob = Struct.new(:path)
8

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

15
  let(:message) { 'Test message' }
16

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

    merge_commit_id = repository.merge(user,
                                       merge_request.diff_head_sha,
                                       merge_request,
23
                                       message)
24

25
    repository.commit(merge_commit_id)
26
  end
27

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

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

      expect(known_exception).not_to be_nil
37 38 39
    end
  end

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

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

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

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

59
  describe '#tag_names_contains' do
60
    subject { repository.tag_names_contains(sample_commit.id) }
61

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

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

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

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

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

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

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

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

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

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

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

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

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

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

169 170 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
  end

220
  describe '#last_commit_for_path' do
221
    subject { repository.last_commit_for_path(sample_commit.id, '.gitignore').id }
222

223
    it { is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8') }
224

225 226 227 228
    describe 'when storage is broken', :broken_storage do
      it 'should raise a storage error' do
        expect_to_raise_storage_error do
          broken_repository.last_commit_id_for_path(sample_commit.id, '.gitignore')
229 230
        end
      end
231
    end
232
  end
233

Hiroyuki Sato's avatar
Hiroyuki Sato committed
234
  describe '#last_commit_id_for_path' do
235
    subject { repository.last_commit_id_for_path(sample_commit.id, '.gitignore') }
Hiroyuki Sato's avatar
Hiroyuki Sato committed
236

237 238 239
    it "returns last commit id for a given path" do
      is_expected.to eq('c1acaa58bbcbc3eafe538cb8274ba387047b69f8')
    end
240

241 242 243
    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')}"
244

245 246 247
      expect(cache).to receive(:fetch).with(key).and_return('c1acaa5')
      is_expected.to eq('c1acaa5')
    end
248

249 250 251 252
    describe 'when storage is broken', :broken_storage do
      it 'should raise a storage error' do
        expect_to_raise_storage_error do
          broken_repository.last_commit_for_path(sample_commit.id, '.gitignore').id
253 254
        end
      end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
255
    end
Hiroyuki Sato's avatar
Hiroyuki Sato committed
256 257
  end

258
  describe '#commits' do
Tiago Botelho's avatar
Tiago Botelho committed
259 260 261 262
    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
263 264
    end

Tiago Botelho's avatar
Tiago Botelho committed
265 266 267 268
    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
269

Tiago Botelho's avatar
Tiago Botelho committed
270 271 272 273 274 275 276 277 278 279 280 281 282
      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
283

Tiago Botelho's avatar
Tiago Botelho committed
284 285
        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
286

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

307
  describe '#new_commits' do
308 309
    set(:project) { create(:project, :repository) }
    let(:repository) { project.repository }
310

311
    subject { repository.new_commits(rev) }
312

313 314
    context 'when there are no new commits' do
      let(:rev) { repository.commit.id }
315

316 317
      it 'returns an empty array' do
        expect(subject).to eq([])
318
      end
319
    end
320

321 322 323
    context 'when new commits are found' do
      let(:branch) { 'orphaned-branch' }
      let!(:rev) { repository.commit(branch).id }
324

325 326
      it 'returns the commits' do
        repository.delete_branch(branch)
327

328 329 330
        expect(subject).not_to be_empty
        expect(subject).to all( be_a(::Commit) )
        expect(subject.size).to eq(1)
331 332
      end
    end
333 334
  end

335 336
  describe '#commits_by' do
    set(:project) { create(:project, :repository) }
337
    let(:oids) { TestEnv::BRANCH_SHA.values }
338

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

341 342 343 344
    it 'finds each commit' do
      expect(subject).not_to include(nil)
      expect(subject.size).to eq(oids.size)
    end
345

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

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

355 356 357
      it 'returns only found commits' do
        expect(subject).not_to include(nil)
        expect(subject.size).to eq(10)
358
      end
359
    end
360

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

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

367
        subject
368 369 370 371
      end
    end
  end

372
  describe '#find_commits_by_message' do
373 374
    it 'returns commits with messages containing a given string' do
      commit_ids = repository.find_commits_by_message('submodule').map(&:id)
375

376 377 378 379 380 381
      expect(commit_ids).to include(
        '5937ac0a7beb003549fc5fd26fc247adbce4a52e',
        '6f6d7e7ed97bb5f0054f2b1df789b39ca89b6ff9',
        'cfe32cf61b73a0d5e9f13e774abde7ff789b1660'
      )
      expect(commit_ids).not_to include('913c66a37b4a45b9769037c55c2d238bd0942d2e')
382 383
    end

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

387
      expect(commit_ids).to include('5937ac0a7beb003549fc5fd26fc247adbce4a52e')
388
    end
389

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

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

      it { is_expected.to be_nil }
    end
403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420

    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
421
  end
422

423
  describe '#merged_to_root_ref?' do
424
    context 'merged branch without ff' do
425
      subject { repository.merged_to_root_ref?('branch-merged') }
426 427 428

      it { is_expected.to be_truthy }
    end
429

430 431
    # If the HEAD was ff then it will be false
    context 'merged with ff' do
432 433 434 435
      subject { repository.merged_to_root_ref?('improve/awesome') }

      it { is_expected.to be_truthy }
    end
436

437 438 439 440 441
    context 'not merged branch' do
      subject { repository.merged_to_root_ref?('not-merged-branch') }

      it { is_expected.to be_falsey }
    end
442 443 444 445 446 447

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

      it { is_expected.to be_falsey }
    end
448 449 450 451 452 453 454 455 456 457 458 459

    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
460 461
  end

462
  describe '#can_be_merged?' do
463 464
    context 'mergeable branches' do
      subject { repository.can_be_merged?('0b4bc9a49b562e85de7cc9e834518ea6828729b9', 'master') }
465

466 467
      it { is_expected.to be_truthy }
    end
468

469 470
    context 'non-mergeable branches without conflict sides missing' do
      subject { repository.can_be_merged?('bb5206fee213d983da88c47f9cf4cc6caf9c66dc', 'feature') }
471

472 473
      it { is_expected.to be_falsey }
    end
474

475 476
    context 'non-mergeable branches with conflict sides missing' do
      subject { repository.can_be_merged?('conflict-missing-side', 'conflict-start') }
477

478 479
      it { is_expected.to be_falsey }
    end
480

481 482
    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') }
483

484
      it { is_expected.to be_falsey }
485
    end
486 487
  end

488 489 490
  describe '#commit' do
    context 'when ref exists' do
      it 'returns commit object' do
491 492
        expect(repository.commit('master'))
          .to be_an_instance_of Commit
493 494 495 496 497 498 499 500 501
      end
    end

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

502 503 504 505 506 507 508 509
    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

510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
    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
525
  describe "#create_dir" do
526 527
    it "commits a change that creates a new directory" do
      expect do
528
        repository.create_dir(user, 'newdir',
529
          message: 'Create newdir', branch_name: 'master')
530
      end.to change { repository.count_commits(ref: 'master') }.by(1)
531 532 533 534 535

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

536
    context "when committing to another project" do
537
      let(:forked_project) { create(:project, :repository) }
538 539 540

      it "creates a fork and commit to the forked project" do
        expect do
541
          repository.create_dir(user, 'newdir',
542
            message: 'Create newdir', branch_name: 'patch',
Lin Jen-Shin's avatar
Lin Jen-Shin committed
543
            start_branch_name: 'master', start_project: forked_project)
544
        end.to change { repository.count_commits(ref: 'master') }.by(0)
545 546 547 548 549 550 551 552 553

        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

554 555 556
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
557
          repository.create_dir(user, 'newdir',
558 559 560
            message: 'Add newdir',
            branch_name: 'master',
            author_email: author_email, author_name: author_name)
561
        end.to change { repository.count_commits(ref: 'master') }.by(1)
562 563 564 565 566 567 568 569 570

        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

571 572
  describe "#create_file" do
    it 'commits new file successfully' do
573
      expect do
574 575 576
        repository.create_file(user, 'NEWCHANGELOG', 'Changelog!',
                               message: 'Create changelog',
                               branch_name: 'master')
577
      end.to change { repository.count_commits(ref: 'master') }.by(1)
578

579
      blob = repository.blob_at('master', 'NEWCHANGELOG')
580

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

584
    it 'creates new file and dir when file_path has a forward slash' do
585
      expect do
586 587
        repository.create_file(user, 'new_dir/new_file.txt', 'File!',
                               message: 'Create new_file with new_dir',
588
                               branch_name: 'master')
589
      end.to change { repository.count_commits(ref: 'master') }.by(1)
590

591 592
      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!')
593 594
    end

595
    it 'respects the autocrlf setting' do
596
      repository.create_file(user, 'hello.txt', "Hello,\r\nWorld",
597
                             message: 'Add hello world',
598
                             branch_name: 'master')
599 600 601 602 603 604

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

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

605 606 607
    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
608
          repository.create_file(user, 'NEWREADME', 'README!',
609 610 611 612
                                 message: 'Add README',
                                 branch_name: 'master',
                                 author_email: author_email,
                                 author_name: author_name)
613
        end.to change { repository.count_commits(ref: 'master') }.by(1)
614 615 616 617 618 619 620

        last_commit = repository.commit

        expect(last_commit.author_email).to eq(author_email)
        expect(last_commit.author_name).to eq(author_name)
      end
    end
621 622
  end

623
  describe "#update_file" do
624 625 626 627 628
    it 'updates file successfully' do
      expect do
        repository.update_file(user, 'CHANGELOG', 'Changelog!',
                               message: 'Update changelog',
                               branch_name: 'master')
629
      end.to change { repository.count_commits(ref: 'master') }.by(1)
630 631 632 633 634 635

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

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

636
    it 'updates filename successfully' do
637 638
      expect do
        repository.update_file(user, 'NEWLICENSE', 'Copyright!',
639
                                     branch_name: 'master',
640
                                     previous_path: 'LICENSE',
641
                                     message: 'Changes filename')
642
      end.to change { repository.count_commits(ref: 'master') }.by(1)
643 644 645 646 647 648

      files = repository.ls_files('master')

      expect(files).not_to include('LICENSE')
      expect(files).to include('NEWLICENSE')
    end
649 650 651 652

    context "when an author is specified" do
      it "uses the given email/name to set the commit's author" do
        expect do
653 654 655 656 657 658
          repository.update_file(user, 'README', 'Updated README!',
                                 branch_name: 'master',
                                 previous_path: 'README',
                                 message: 'Update README',
                                 author_email: author_email,
                                 author_name: author_name)
659
        end.to change { repository.count_commits(ref: 'master') }.by(1)
660 661 662 663 664 665 666 667 668

        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
669
  describe "#delete_file" do
670 671
    it 'removes file successfully' do
      expect do
672
        repository.delete_file(user, 'README',
673
          message: 'Remove README', branch_name: 'master')
674
      end.to change { repository.count_commits(ref: 'master') }.by(1)
675 676 677 678 679 680 681

      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
682
          repository.delete_file(user, 'README',
683 684
            message: 'Remove README', branch_name: 'master',
            author_email: author_email, author_name: author_name)
685
        end.to change { repository.count_commits(ref: 'master') }.by(1)
686 687 688 689 690 691 692 693 694

        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

695
  describe "search_files_by_content" do
696
    let(:results) { repository.search_files_by_content('feature', 'master') }
697 698 699 700
    subject { results }

    it { is_expected.to be_an Array }

701
    it 'regex-escapes the query string' do
702
      results = repository.search_files_by_content("test\\", 'master')
703 704 705 706

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

707
    it 'properly handles an unmatched parenthesis' do
708
      results = repository.search_files_by_content("test(", 'master')
709 710 711 712

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

Valery Sizov's avatar
Valery Sizov committed
713
    it 'properly handles when query is not present' do
714
      results = repository.search_files_by_content('', 'master')
Valery Sizov's avatar
Valery Sizov committed
715 716 717 718 719

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

    it 'properly handles query when repo is empty' do
720
      repository = create(:project, :empty_repo).repository
721
      results = repository.search_files_by_content('test', 'master')
Valery Sizov's avatar
Valery Sizov committed
722 723 724 725

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

726
    describe 'when storage is broken', :broken_storage do
727 728 729 730 731 732 733
      it 'should raise a storage error' do
        expect_to_raise_storage_error do
          broken_repository.search_files_by_content('feature', 'master')
        end
      end
    end

734 735 736 737
    describe 'result' do
      subject { results.first }

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

742
  describe "search_files_by_name" do
743 744 745 746 747 748
    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
749 750
    it 'ignores leading slashes' do
      results = repository.search_files_by_name('/files', 'master')
751

752 753 754
      expect(results.first).to eq('files/html/500.html')
    end

755
    it 'properly handles when query is only slashes' do
756
      results = repository.search_files_by_name('//', 'master')
757

758
      expect(results).to match_array([])
759 760
    end

761 762 763 764 765 766 767
    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
768
      repository = create(:project, :empty_repo).repository
769 770 771 772 773

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

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

775
    describe 'when storage is broken', :broken_storage do
776 777 778 779 780 781
      it 'should raise a storage error' do
        expect_to_raise_storage_error { broken_repository.search_files_by_name('files', 'master') }
      end
    end
  end

782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
  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

814
  describe '#fetch_ref' do
815
    let(:broken_repository) { create(:project, :broken_storage).repository }
816

817
    describe 'when storage is broken', :broken_storage do
818
      it 'should raise a storage error' do
819 820 821
        expect_to_raise_storage_error do
          broken_repository.fetch_ref(broken_repository, source_ref: '1', target_ref: '2')
        end
822 823
      end
    end
824 825
  end

826
  describe '#create_ref' do
827
    it 'redirects the call to write_ref' do
828 829
      ref, ref_path = '1', '2'

830
      expect(repository.raw_repository).to receive(:write_ref).with(ref_path, ref)
831 832 833 834 835

      repository.create_ref(ref, ref_path)
    end
  end

836
  describe "#changelog", :use_clean_rails_memory_store_caching do
837 838 839
    it 'accepts changelog' do
      expect(repository.tree).to receive(:blobs).and_return([TestBlob.new('changelog')])

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

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

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

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

852
      expect(repository.changelog.path).to eq('history')
853 854 855 856 857
    end

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

858
      expect(repository.changelog.path).to eq('changes')
859 860 861 862 863
    end

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

864
      expect(repository.changelog.path).to eq('CHANGELOG')
865 866 867
    end
  end

868
  describe "#license_blob", :use_clean_rails_memory_store_caching do
869
    before do
870
      repository.delete_file(
871
        user, 'LICENSE', message: 'Remove LICENSE', branch_name: 'master')
872 873
    end

874
    it 'handles when HEAD points to non-existent ref' do
875
      repository.create_file(
876
        user, 'LICENSE', 'Copyright!',
877
        message: 'Add LICENSE', branch_name: 'master')
878

879
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
880 881 882 883

      expect(repository.license_blob).to be_nil
    end

884
    it 'looks in the root_ref only' do
885
      repository.delete_file(user, 'LICENSE',
886
        message: 'Remove LICENSE', branch_name: 'markdown')
887
      repository.create_file(user, 'LICENSE',
888
        Licensee::License.new('mit').content,
889
        message: 'Add LICENSE', branch_name: 'markdown')
890 891 892 893

      expect(repository.license_blob).to be_nil
    end

894
    it 'detects license file with no recognizable open-source license content' do
895 896
      repository.create_file(user, 'LICENSE', 'Copyright!',
        message: 'Add LICENSE', branch_name: 'master')
897

898
      expect(repository.license_blob.path).to eq('LICENSE')
899 900
    end

901 902
    %w[LICENSE LICENCE LiCensE LICENSE.md LICENSE.foo COPYING COPYING.md].each do |filename|
      it "detects '#{filename}'" do
903
        repository.create_file(user, filename,
904
          Licensee::License.new('mit').content,
905
          message: "Add #{filename}", branch_name: 'master')
906

907 908
        expect(repository.license_blob.name).to eq(filename)
      end
909 910 911
    end
  end

912
  describe '#license_key', :use_clean_rails_memory_store_caching do
913
    before do
914
      repository.delete_file(user, 'LICENSE',
915
        message: 'Remove LICENSE', branch_name: 'master')
916
    end
917

918
    it 'returns nil when no license is detected' do
919 920 921
      expect(repository.license_key).to be_nil
    end

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

925 926 927
      expect(repository.license_key).to be_nil
    end

928
    it 'returns nil when the content is not recognizable' do
929
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
930
        message: 'Add LICENSE', branch_name: 'master')
931 932

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

935 936 937 938 939 940
    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

941
    it 'returns nil when master does not exist' do
942 943
      repository.rm_branch(user, 'master')

944
      expect(repository.license_key).to be_nil
945 946
    end

947
    it 'returns the license key' do
948
      repository.create_file(user, 'LICENSE',
949
        Licensee::License.new('mit').content,
950
        message: 'Add LICENSE', branch_name: 'master')
951

952
      expect(repository.license_key).to eq('mit')
953
    end
954
  end
955

956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972
  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
973
      repository.create_file(user, 'LICENSE', 'Gitlab B.V.',
974 975 976 977 978 979 980 981 982 983 984 985 986 987 988
        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

989
  describe "#gitlab_ci_yml", :use_clean_rails_memory_store_caching do
990 991 992 993
    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)

994
      expect(repository.gitlab_ci_yml.path).to eq('.gitlab-ci.yml')
995 996 997 998 999 1000 1001 1002
    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
1003
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
1004 1005 1006 1007
      expect(repository.gitlab_ci_yml).to be_nil
    end
  end

1008
  describe '#add_branch' do
1009 1010
    let(:branch_name) { 'new_feature' }
    let(:target) { 'master' }
1011

1012
    subject { repository.add_branch(user, branch_name, target) }
1013

1014 1015 1016 1017
    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)
1018

1019
      subject
1020 1021
    end

1022 1023 1024 1025
    it 'creates_the_branch' do
      expect(subject.name).to eq(branch_name)
      expect(repository.find_branch(branch_name)).not_to be_nil
    end
1026

1027 1028
    context 'with a non-existing target' do
      let(:target) { 'fake-target' }
1029

1030 1031 1032
      it "returns false and doesn't create the branch" do
        expect(subject).to be(false)
        expect(repository.find_branch(branch_name)).to be_nil
1033 1034 1035 1036
      end
    end
  end

1037
  describe '#exists?' do
1038
    it 'returns true when a repository exists' do
1039
      expect(repository.exists?).to be(true)
1040 1041
    end

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

1045
      expect(repository.exists?).to be(false)
1046
    end
1047

1048
    context 'with broken storage', :broken_storage do
1049 1050 1051 1052
      it 'should raise a storage error' do
        expect_to_raise_storage_error { broken_repository.exists? }
      end
    end
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093

    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
          expect(repository.raw_repository).to receive(:exists?).once.and_return(true)
        end

        it 'caches the output in RequestStore' do
          expect do
            repository.exists?
          end.to change { request_store_cache.read(:exists?) }.from(nil).to(true)
        end

        it 'caches the output in RepositoryCache' do
          expect do
            repository.exists?
          end.to change { cache.read(:exists?) }.from(nil).to(true)
        end
      end

      context 'when it returns false' do
        before do
          expect(repository.raw_repository).to receive(:exists?).once.and_return(false)
        end

        it 'caches the output in RequestStore' do
          expect do
            repository.exists?
          end.to change { request_store_cache.read(:exists?) }.from(nil).to(false)
        end

        it 'does NOT cache the output in RepositoryCache' do
          expect do
            repository.exists?
          end.not_to change { cache.read(:exists?) }.from(nil)
        end
      end
    end
1094
  end
1095

1096
  describe '#has_visible_content?' do
1097 1098 1099 1100 1101 1102 1103
    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
1104

1105 1106
    context 'when true' do
      let(:result) { true }
1107

1108 1109 1110 1111 1112
      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
1113 1114
    end

1115 1116
    context 'when false' do
      let(:result) { false }
1117

1118 1119 1120 1121
      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)
1122 1123 1124 1125
      end
    end
  end

1126 1127 1128 1129 1130 1131 1132 1133 1134
  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

1135 1136 1137 1138 1139 1140 1141 1142 1143
  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

1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
  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

1160 1161 1162 1163
  describe '#empty?' do
    let(:empty_repository) { create(:project_empty_repo).repository }

    it 'returns true for an empty repository' do
1164
      expect(empty_repository).to be_empty
1165 1166 1167
    end

    it 'returns false for a non-empty repository' do
1168
      expect(repository).not_to be_empty
1169 1170 1171
    end

    it 'caches the output' do
1172
      expect(repository.raw_repository).to receive(:has_visible_content?).once
1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184

      repository.empty?
      repository.empty?
    end
  end

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

    it 'caches the output' do
1185 1186 1187
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('master')
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197

      repository.root_ref
      repository.root_ref
    end
  end

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

1198 1199 1200
      expect(repository.raw_repository).to receive(:root_ref)
        .once
        .and_return('foo')
1201 1202 1203 1204 1205 1206 1207

      repository.expire_root_ref_cache

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

1208
  describe '#expire_branch_cache' do
1209 1210 1211 1212 1213
    # 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
1214 1215 1216
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1217 1218 1219 1220 1221

      repository.expire_branch_cache
    end

    it 'expires the cache for all branches when the root branch is given' do
1222 1223 1224
      expect(cache).to receive(:expire)
        .at_least(repository.branches.length * 2)
        .times
1225 1226 1227 1228 1229

      repository.expire_branch_cache(repository.root_ref)
    end

    it 'expires the cache for a specific branch' do
1230
      expect(cache).to receive(:expire).twice
1231 1232 1233 1234

      repository.expire_branch_cache('foo')
    end
  end
1235

1236 1237 1238
  describe '#expire_emptiness_caches' do
    let(:cache) { repository.send(:cache) }

1239 1240 1241
    it 'expires the caches for an empty repository' do
      allow(repository).to receive(:empty?).and_return(true)

1242
      expect(cache).to receive(:expire).with(:has_visible_content?)
1243 1244 1245

      repository.expire_emptiness_caches
    end
1246 1247 1248 1249

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

1250
      expect(cache).not_to receive(:expire).with(:has_visible_content?)
1251 1252 1253

      repository.expire_emptiness_caches
    end
1254 1255 1256 1257 1258 1259

    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
1260 1261
  end

1262
  describe 'skip_merges option' do
1263
    subject { repository.commits(Gitlab::Git::BRANCH_REF_PREFIX + "'test'", limit: 100, skip_merges: true).map { |k| k.id } }
1264 1265 1266

    it { is_expected.not_to include('e56497bb5f03a90a51293fc6d516788730953899') }
  end
1267 1268

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

1272 1273 1274 1275
    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
1276

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

1280
      expect(merge_request.in_progress_merge_commit_sha).to eq(merge_commit_id)
1281
    end
1282

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

1286
      expect(repository.commit(merge_commit_id).message).to eq(message.delete("\r"))
1287 1288
    end

1289 1290
    def merge(repository, user, merge_request, message)
      repository.merge(user, merge_request.diff_head_sha, merge_request, message)
1291
    end
1292 1293
  end

1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321
  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

1322
  describe '#revert' do
1323 1324 1325
    let(:new_image_commit) { repository.commit('33f3729a45c02fc67d00adb1b8bca394b0e761d9') }
    let(:update_image_commit) { repository.commit('2f63565e7aac07bcdadb654e253078b727143ec4') }
    let(:message) { 'revert message' }
1326

1327 1328 1329
    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)
1330
      end
1331
    end
1332

1333 1334 1335
    context 'when commit was already reverted' do
      it 'raises an error' do
        repository.revert(user, update_image_commit, 'master', message)
1336

1337
        expect { repository.revert(user, update_image_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
1338
      end
1339
    end
1340

1341 1342 1343 1344
    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
1345 1346
    end

1347 1348 1349 1350 1351 1352 1353 1354
    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
1355
    end
1356
  end
1357

1358
  describe '#cherry_pick' do
1359 1360 1361 1362 1363 1364 1365 1366
    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)
1367
      end
1368
    end
1369

1370 1371 1372
    context 'when commit was already cherry-picked' do
      it 'raises an error' do
        repository.cherry_pick(user, pickable_commit, 'master', message)
1373

1374
        expect { repository.cherry_pick(user, pickable_commit, 'master', message) }.to raise_error(Gitlab::Git::Repository::CreateTreeError)
1375
      end
1376
    end
1377

1378 1379 1380
    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
1381
      end
1382
    end
1383

1384 1385 1386
    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
1387

1388 1389
        cherry_pick_commit_sha = repository.cherry_pick(user, pickable_merge, 'improve/awesome', message)
        cherry_pick_commit_message = project.commit(cherry_pick_commit_sha).message
1390

1391 1392
        expect(repository.blob_at_branch('improve/awesome', 'foo/bar/.gitkeep')).not_to be_nil
        expect(cherry_pick_commit_message).to eq(message)
1393 1394 1395 1396
      end
    end
  end

1397 1398 1399 1400 1401 1402 1403
  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
1404
        expect(repository).not_to receive(:expire_cache)
1405 1406 1407 1408

        repository.before_delete
      end

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
      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

1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
      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
1432 1433

      it 'flushes the exists cache' do
1434
        expect(repository).to receive(:expire_exists_cache).twice
1435 1436 1437

        repository.before_delete
      end
1438 1439 1440 1441 1442 1443 1444
    end

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

1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
      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

1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
      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

1485
  describe '#after_change_head' do
1486
    it 'flushes the method caches' do
1487
      expect(repository).to receive(:expire_method_caches).with([
1488 1489 1490
        :size,
        :commit_count,
        :rendered_readme,
1491
        :readme_path,
1492
        :contribution_guide,
1493
        :changelog,
1494 1495
        :license_blob,
        :license_key,
1496
        :gitignore,
1497 1498 1499 1500 1501
        :gitlab_ci_yml,
        :branch_names,
        :tag_names,
        :branch_count,
        :tag_count,
1502
        :avatar,
1503 1504 1505 1506 1507 1508
        :exists?,
        :root_ref,
        :has_visible_content?,
        :issue_template_names,
        :merge_request_template_names,
        :xcode_project?
1509 1510 1511 1512 1513 1514
      ])

      repository.after_change_head
    end
  end

1515
  describe '#before_push_tag' do
1516
    it 'flushes the cache' do
1517 1518 1519
      expect(repository).to receive(:expire_statistics_caches)
      expect(repository).to receive(:expire_emptiness_caches)
      expect(repository).to receive(:expire_tags_cache)
1520

1521
      repository.before_push_tag
1522 1523 1524 1525
    end
  end

  describe '#after_import' do
1526 1527
    it 'flushes and builds the cache' do
      expect(repository).to receive(:expire_content_cache)
1528 1529 1530

      repository.after_import
    end
1531 1532 1533
  end

  describe '#after_push_commit' do
1534
    it 'expires statistics caches' do
1535 1536
      expect(repository).to receive(:expire_statistics_caches)
        .and_call_original
1537

1538 1539 1540
      expect(repository).to receive(:expire_branch_cache)
        .with('master')
        .and_call_original
1541

1542
      repository.after_push_commit('master')
1543 1544 1545 1546
    end
  end

  describe '#after_create_branch' do
1547
    it 'expires the branch caches' do
1548
      expect(repository).to receive(:expire_branches_cache)
1549 1550 1551 1552 1553 1554

      repository.after_create_branch
    end
  end

  describe '#after_remove_branch' do
1555
    it 'expires the branch caches' do
1556
      expect(repository).to receive(:expire_branches_cache)
1557 1558 1559 1560

      repository.after_remove_branch
    end
  end
1561

1562 1563 1564 1565 1566 1567
  describe '#after_create' do
    it 'flushes the exists cache' do
      expect(repository).to receive(:expire_exists_cache)

      repository.after_create
    end
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579

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

      repository.after_create
    end

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

      repository.after_create
    end
1580 1581
  end

1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
  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

1592 1593
  describe '#before_remove_tag' do
    it 'flushes the tag cache' do
1594 1595
      expect(repository).to receive(:expire_tags_cache).and_call_original
      expect(repository).to receive(:expire_statistics_caches).and_call_original
1596 1597 1598 1599 1600 1601 1602

      repository.before_remove_tag
    end
  end

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

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

1607
      expect(repository.branch_count).to eq(rugged_count)
1608 1609 1610 1611 1612
    end
  end

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

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

1617
      expect(repository.tag_count).to eq(rugged_count)
1618 1619 1620
    end
  end

1621
  describe '#expire_branches_cache' do
1622
    it 'expires the cache' do
1623
      expect(repository).to receive(:expire_method_caches)
1624
        .with(%i(branch_names branch_count has_visible_content?))
1625
        .and_call_original
1626

1627
      repository.expire_branches_cache
1628 1629 1630
    end
  end

1631
  describe '#expire_tags_cache' do
1632
    it 'expires the cache' do
1633 1634 1635
      expect(repository).to receive(:expire_method_caches)
        .with(%i(tag_names tag_count))
        .and_call_original
1636

1637
      repository.expire_tags_cache
1638 1639
    end
  end
1640

1641
  describe '#add_tag' do
1642
    let(:user) { build_stubbed(:user) }
1643

1644 1645 1646
    context 'with a valid target' do
      it 'creates the tag' do
        repository.add_tag(user, '8.5', 'master', 'foo')
1647

1648 1649 1650 1651
        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)
1652
      end
1653

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

1657 1658 1659
        expect(tag).to be_a(Gitlab::Git::Tag)
      end
    end
1660

1661 1662 1663
    context 'with an invalid target' do
      it 'returns false' do
        expect(repository.add_tag(user, '8.5', 'bar', 'foo')).to be false
1664
      end
1665 1666 1667
    end
  end

1668
  describe '#rm_branch' do
1669 1670 1671
    it 'removes a branch' do
      expect(repository).to receive(:before_remove_branch)
      expect(repository).to receive(:after_remove_branch)
1672

1673
      repository.rm_branch(user, 'feature')
1674
    end
1675

1676 1677 1678 1679
    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)
1680 1681
      end

1682 1683 1684 1685
      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)
1686

1687
        expect(repository.find_branch('feature')).not_to be_nil
1688
      end
1689 1690
    end
  end
1691 1692

  describe '#rm_tag' do
1693 1694
    it 'removes a tag' do
      expect(repository).to receive(:before_remove_tag)
1695

1696
      repository.rm_tag(build_stubbed(:user), 'v1.1.0')
1697

1698
      expect(repository.find_tag('v1.1.0')).to be_nil
1699 1700
    end
  end
1701

1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729
  describe '#find_ref' do
    subject { repository.find_ref(ref) }

    context 'when ref is a tag' do
      let(:ref) { 'refs/tags/v1.0.0' }

      it 'returns the tag' do
        is_expected.to be_a(Gitlab::Git::Tag)
      end
    end

    context 'when ref is a branch' do
      let(:ref) { 'refs/heads/master' }

      it 'returns the branch' do
        is_expected.to be_a(Gitlab::Git::Branch)
      end
    end

    context 'when ref is invalid' do
      let(:ref) { 'refs/notvalid/ref' }

      it 'returns nil' do
        is_expected.to eq(nil)
      end
    end
  end

1730
  describe '#avatar' do
1731
    it 'returns nil if repo does not exist' do
1732
      allow(repository).to receive(:root_ref).and_raise(Gitlab::Git::Repository::NoRepository)
1733 1734 1735 1736

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

1737
    it 'returns the first avatar file found in the repository' do
1738 1739 1740
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .and_return(double(:tree, path: 'logo.png'))
1741 1742 1743 1744 1745

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

    it 'caches the output' do
1746 1747 1748 1749
      expect(repository).to receive(:file_on_head)
        .with(:avatar)
        .once
        .and_return(double(:tree, path: 'logo.png'))
1750

1751
      2.times { expect(repository.avatar).to eq('logo.png') }
1752 1753
    end
  end
1754

1755 1756
  describe '#expire_exists_cache' do
    let(:cache) { repository.send(:cache) }
1757
    let(:request_store_cache) { repository.send(:request_store_cache) }
1758 1759 1760 1761 1762 1763

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

      repository.expire_exists_cache
    end
1764 1765 1766 1767 1768 1769

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

      repository.expire_exists_cache
    end
1770 1771
  end

1772 1773
  describe '#xcode_project?' do
    before do
1774
      allow(repository).to receive(:tree).with(:head).and_return(double(:tree, trees: [tree]))
1775 1776
    end

1777 1778
    context 'when the root contains a *.xcodeproj directory' do
      let(:tree) { double(:tree, path: 'Foo.xcodeproj') }
1779 1780 1781 1782 1783 1784

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

1785 1786
    context 'when the root contains a *.xcworkspace directory' do
      let(:tree) { double(:tree, path: 'Foo.xcworkspace') }
1787 1788 1789 1790 1791 1792

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

1793 1794
    context 'when the root contains no Xcode config directory' do
      let(:tree) { double(:tree, path: 'Foo') }
1795 1796 1797 1798 1799 1800 1801

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

1802
  describe "#keep_around" do
1803 1804 1805 1806
    it "does not fail if we attempt to reference bad commit" do
      expect(repository.kept_around?('abc1234')).to be_falsey
    end

1807 1808 1809 1810 1811
    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
1812 1813 1814 1815

    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)
1816 1817 1818 1819

      path = Gitlab::GitalyClient::StorageSettings.allow_disk_access do
        File.join(repository.path, ref)
      end
1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830
      # 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
1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848

    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
1849
  end
1850

1851
  describe '#contribution_guide', :use_clean_rails_memory_store_caching do
1852
    it 'returns and caches the output' do
1853 1854 1855 1856
      expect(repository).to receive(:file_on_head)
        .with(:contributing)
        .and_return(Gitlab::Git::Tree.new(path: 'CONTRIBUTING.md'))
        .once
1857 1858

      2.times do
1859 1860
        expect(repository.contribution_guide)
          .to be_an_instance_of(Gitlab::Git::Tree)
1861 1862 1863 1864
      end
    end
  end

1865
  describe '#gitignore', :use_clean_rails_memory_store_caching do
1866
    it 'returns and caches the output' do
1867 1868 1869 1870
      expect(repository).to receive(:file_on_head)
        .with(:gitignore)
        .and_return(Gitlab::Git::Tree.new(path: '.gitignore'))
        .once
1871 1872

      2.times do
1873
        expect(repository.gitignore).to be_an_instance_of(Gitlab::Git::Tree)
1874 1875 1876 1877
      end
    end
  end

1878
  describe '#readme', :use_clean_rails_memory_store_caching do
1879
    context 'with a non-existing repository' do
1880
      let(:project) { create(:project) }
1881

1882
      it 'returns nil' do
1883 1884 1885
        expect(repository.readme).to be_nil
      end
    end
1886

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

1891
        it 'returns nil' do
1892 1893 1894 1895 1896
          expect(repository.readme).to be_nil
        end
      end

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

1899 1900 1901
        it 'returns the README' do
          expect(repository.readme).to be_an_instance_of(ReadmeBlob)
        end
1902 1903 1904 1905
      end
    end
  end

1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
  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

1942 1943
  describe '#expire_statistics_caches' do
    it 'expires the caches' do
1944 1945
      expect(repository).to receive(:expire_method_caches)
        .with(%i(size commit_count))
1946

1947 1948 1949 1950 1951 1952
      repository.expire_statistics_caches
    end
  end

  describe '#expire_all_method_caches' do
    it 'expires the caches of all methods' do
1953 1954
      expect(repository).to receive(:expire_method_caches)
        .with(Repository::CACHED_METHODS)
1955 1956 1957

      repository.expire_all_method_caches
    end
1958 1959 1960 1961 1962 1963 1964

    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

1965
      expect(Repository::CACHED_METHODS + Repository::MEMOIZED_CACHED_METHODS).to include(*methods)
1966
    end
1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
  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
1988 1989
        expect(repository.file_on_head(:readme))
          .to be_an_instance_of(Gitlab::Git::Tree)
1990 1991 1992 1993
      end
    end
  end

1994 1995 1996 1997 1998 1999
  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
2000

2001 2002 2003 2004 2005
    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
2006 2007 2008 2009
      end
    end
  end

2010 2011 2012 2013 2014
  describe '#tree' do
    context 'using a non-existing repository' do
      before do
        allow(repository).to receive(:head_commit).and_return(nil)
      end
2015

2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
      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

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

2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
  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
2070
        expect(repository.commit_count).to be_an(Integer)
2071 2072 2073 2074
      end
    end
  end

2075
  describe '#commit_count_for_ref' do
2076
    let(:project) { create :project }
2077

2078 2079
    context 'with a non-existing repository' do
      it 'returns 0' do
2080 2081 2082 2083 2084 2085 2086 2087
        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)
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
      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

2098 2099 2100 2101 2102 2103 2104 2105 2106
  describe '#diverging_commit_counts' do
    it 'returns the commit counts behind and ahead of default branch' do
      result = repository.diverging_commit_counts(
        repository.find_branch('fix'))

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

2107 2108
  describe '#refresh_method_caches' do
    it 'refreshes the caches of the given types' do
2109
      expect(repository).to receive(:expire_method_caches)
2110
        .with(%i(rendered_readme readme_path license_blob license_key license))
2111

2112
      expect(repository).to receive(:rendered_readme)
2113
      expect(repository).to receive(:readme_path)
2114 2115
      expect(repository).to receive(:license_blob)
      expect(repository).to receive(:license_key)
2116
      expect(repository).to receive(:license)
2117 2118 2119

      repository.refresh_method_caches(%i(readme license))
    end
2120
  end
Douwe Maan's avatar
Douwe Maan committed
2121 2122 2123

  describe '#gitlab_ci_yml_for' do
    before do
2124
      repository.create_file(User.last, '.gitlab-ci.yml', 'CONTENT', message: 'Add .gitlab-ci.yml', branch_name: 'master')
Douwe Maan's avatar
Douwe Maan committed
2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141
    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
2142
      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
2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
    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
2157

2158
  def create_remote_branch(remote_name, branch_name, target)
2159
    rugged = rugged_repo(repository)
2160 2161 2162
    rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", target.id)
  end

2163
  describe '#ancestor?' do
2164 2165
    let(:commit) { repository.commit }
    let(:ancestor) { commit.parents.first }
2166

2167 2168 2169
    it 'it is an ancestor' do
      expect(repository.ancestor?(ancestor.id, commit.id)).to eq(true)
    end
2170

2171 2172
    it 'it is not an ancestor' do
      expect(repository.ancestor?(commit.id, ancestor.id)).to eq(false)
2173
    end
2174

2175 2176 2177 2178
    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)
2179
    end
2180

2181 2182 2183
    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)
2184 2185
    end
  end
2186

2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
  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

2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
  describe 'commit cache' do
    set(:project) { create(:project, :repository) }

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

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

      project.commit_by(oid: oid)
    end

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

      project.commit_by(oid: '1' * 40)
      project.commit_by(oid: '1' * 40)
    end
  end
2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251

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

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

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

      it 'creates a Gitlab::Git::Repository with the proper attributes' do
        expect(subject).to be_a(Gitlab::Git::Repository)
        expect(subject.relative_path).to eq(project.disk_path + '.wiki.git')
        expect(subject.gl_repository).to eq("wiki-#{project.id}")
      end
    end
  end
2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358

  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
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369

  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
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387

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

    it 'returns a RepositoryCache' do
      expect(subject).to be_kind_of Gitlab::RepositoryCache
    end

    it 'when is_wiki it includes wiki as part of key' do
      allow(repository).to receive(:is_wiki) { true }

      expect(subject.namespace).to include('wiki')
    end

    it 'when is_wiki is false extra_namespace is nil' do
      expect(subject.namespace).not_to include('wiki')
    end
  end
2388
end