repository_spec.rb 70.8 KB
Newer Older
1
# coding: utf-8
Robert Speicher's avatar
Robert Speicher committed
2 3
require "spec_helper"

4
describe Gitlab::Git::Repository, :seed_helper do
5
  include Gitlab::EncodingHelper
6
  using RSpec::Parameterized::TableSyntax
Robert Speicher's avatar
Robert Speicher committed
7

8 9 10 11 12 13 14 15 16 17 18 19 20 21
  shared_examples 'wrapping gRPC errors' do |gitaly_client_class, gitaly_client_method|
    it 'wraps gRPC not found error' do
      expect_any_instance_of(gitaly_client_class).to receive(gitaly_client_method)
        .and_raise(GRPC::NotFound)
      expect { subject }.to raise_error(Gitlab::Git::Repository::NoRepository)
    end

    it 'wraps gRPC unknown error' do
      expect_any_instance_of(gitaly_client_class).to receive(gitaly_client_method)
        .and_raise(GRPC::Unknown)
      expect { subject }.to raise_error(Gitlab::Git::CommandError)
    end
  end

22
  let(:mutable_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '', 'group/project') }
23 24
  let(:mutable_repository_path) { File.join(TestEnv.repos_path, mutable_repository.relative_path) }
  let(:mutable_repository_rugged) { Rugged::Repository.new(mutable_repository_path) }
25
  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
26 27
  let(:repository_path) { File.join(TestEnv.repos_path, repository.relative_path) }
  let(:repository_rugged) { Rugged::Repository.new(repository_path) }
28
  let(:storage_path) { TestEnv.repos_path }
29
  let(:user) { build(:user) }
Robert Speicher's avatar
Robert Speicher committed
30

31
  describe '.create_hooks' do
32
    let(:repo_path) { File.join(storage_path, 'hook-test.git') }
33
    let(:hooks_dir) { File.join(repo_path, 'hooks') }
34
    let(:target_hooks_dir) { Gitlab::Shell.new.hooks_path }
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
    let(:existing_target) { File.join(repo_path, 'foobar') }

    before do
      FileUtils.rm_rf(repo_path)
      FileUtils.mkdir_p(repo_path)
    end

    context 'hooks is a directory' do
      let(:existing_file) { File.join(hooks_dir, 'my-file') }

      before do
        FileUtils.mkdir_p(hooks_dir)
        FileUtils.touch(existing_file)
        described_class.create_hooks(repo_path, target_hooks_dir)
      end

      it { expect(File.readlink(hooks_dir)).to eq(target_hooks_dir) }
      it { expect(Dir[File.join(repo_path, "hooks.old.*/my-file")].count).to eq(1) }
    end

    context 'hooks is a valid symlink' do
      before do
        FileUtils.mkdir_p existing_target
        File.symlink(existing_target, hooks_dir)
        described_class.create_hooks(repo_path, target_hooks_dir)
      end

      it { expect(File.readlink(hooks_dir)).to eq(target_hooks_dir) }
    end

    context 'hooks is a broken symlink' do
      before do
        FileUtils.rm_f(existing_target)
        File.symlink(existing_target, hooks_dir)
        described_class.create_hooks(repo_path, target_hooks_dir)
      end

      it { expect(File.readlink(hooks_dir)).to eq(target_hooks_dir) }
    end
  end

Robert Speicher's avatar
Robert Speicher committed
76 77 78 79 80 81 82
  describe "Respond to" do
    subject { repository }

    it { is_expected.to respond_to(:root_ref) }
    it { is_expected.to respond_to(:tags) }
  end

83
  describe '#root_ref' do
84
    it 'returns UTF-8' do
85
      expect(repository.root_ref).to be_utf8
86 87
    end

88
    it 'gets the branch name from GitalyClient' do
Andrew Newdigate's avatar
Andrew Newdigate committed
89
      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:default_branch_name)
90 91
      repository.root_ref
    end
92

Andrew Newdigate's avatar
Andrew Newdigate committed
93
    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :default_branch_name do
94
      subject { repository.root_ref }
95
    end
96 97
  end

98
  describe '#branch_names' do
Robert Speicher's avatar
Robert Speicher committed
99 100 101 102 103
    subject { repository.branch_names }

    it 'has SeedRepo::Repo::BRANCHES.size elements' do
      expect(subject.size).to eq(SeedRepo::Repo::BRANCHES.size)
    end
104 105

    it 'returns UTF-8' do
106
      expect(subject.first).to be_utf8
107 108
    end

Robert Speicher's avatar
Robert Speicher committed
109 110
    it { is_expected.to include("master") }
    it { is_expected.not_to include("branch-from-space") }
111

112
    it 'gets the branch names from GitalyClient' do
Andrew Newdigate's avatar
Andrew Newdigate committed
113
      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:branch_names)
114 115
      subject
    end
116

Andrew Newdigate's avatar
Andrew Newdigate committed
117
    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :branch_names
Robert Speicher's avatar
Robert Speicher committed
118 119
  end

120
  describe '#tag_names' do
Robert Speicher's avatar
Robert Speicher committed
121 122 123
    subject { repository.tag_names }

    it { is_expected.to be_kind_of Array }
124

Robert Speicher's avatar
Robert Speicher committed
125 126 127 128
    it 'has SeedRepo::Repo::TAGS.size elements' do
      expect(subject.size).to eq(SeedRepo::Repo::TAGS.size)
    end

129
    it 'returns UTF-8' do
130
      expect(subject.first).to be_utf8
131 132
    end

Robert Speicher's avatar
Robert Speicher committed
133 134 135 136 137 138
    describe '#last' do
      subject { super().last }
      it { is_expected.to eq("v1.2.1") }
    end
    it { is_expected.to include("v1.0.0") }
    it { is_expected.not_to include("v5.0.0") }
139

140
    it 'gets the tag names from GitalyClient' do
Andrew Newdigate's avatar
Andrew Newdigate committed
141
      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:tag_names)
142 143
      subject
    end
144

Andrew Newdigate's avatar
Andrew Newdigate committed
145
    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :tag_names
Robert Speicher's avatar
Robert Speicher committed
146 147
  end

148 149 150
  describe '#archive_metadata' do
    let(:storage_path) { '/tmp' }
    let(:cache_key) { File.join(repository.gl_repository, SeedRepo::LastCommit::ID) }
Robert Speicher's avatar
Robert Speicher committed
151

152 153 154
    let(:append_sha) { true }
    let(:ref) { 'master' }
    let(:format) { nil }
155

156 157 158 159
    let(:expected_extension) { 'tar.gz' }
    let(:expected_filename) { "#{expected_prefix}.#{expected_extension}" }
    let(:expected_path) { File.join(storage_path, cache_key, expected_filename) }
    let(:expected_prefix) { "gitlab-git-test-#{ref}-#{SeedRepo::LastCommit::ID}" }
160

161
    subject(:metadata) { repository.archive_metadata(ref, storage_path, 'gitlab-git-test', format, append_sha: append_sha) }
162

163 164
    it 'sets CommitId to the commit SHA' do
      expect(metadata['CommitId']).to eq(SeedRepo::LastCommit::ID)
165
    end
166

167 168
    it 'sets ArchivePrefix to the expected prefix' do
      expect(metadata['ArchivePrefix']).to eq(expected_prefix)
169
    end
170

171 172 173 174
    it 'sets ArchivePath to the expected globally-unique path' do
      # This is really important from a security perspective. Think carefully
      # before changing it: https://gitlab.com/gitlab-org/gitlab-ce/issues/45689
      expect(expected_path).to include(File.join(repository.gl_repository, SeedRepo::LastCommit::ID))
Robert Speicher's avatar
Robert Speicher committed
175

176 177
      expect(metadata['ArchivePath']).to eq(expected_path)
    end
Robert Speicher's avatar
Robert Speicher committed
178

179 180 181
    context 'append_sha varies archive path and filename' do
      where(:append_sha, :ref, :expected_prefix) do
        sha = SeedRepo::LastCommit::ID
Robert Speicher's avatar
Robert Speicher committed
182

183 184 185 186 187 188 189
        true  | 'master' | "gitlab-git-test-master-#{sha}"
        true  | sha      | "gitlab-git-test-#{sha}-#{sha}"
        false | 'master' | "gitlab-git-test-master"
        false | sha      | "gitlab-git-test-#{sha}"
        nil   | 'master' | "gitlab-git-test-master-#{sha}"
        nil   | sha      | "gitlab-git-test-#{sha}"
      end
Robert Speicher's avatar
Robert Speicher committed
190

191 192 193 194 195
      with_them do
        it { expect(metadata['ArchivePrefix']).to eq(expected_prefix) }
        it { expect(metadata['ArchivePath']).to eq(expected_path) }
      end
    end
Robert Speicher's avatar
Robert Speicher committed
196

197 198 199 200 201 202 203
    context 'format varies archive path and filename' do
      where(:format, :expected_extension) do
        nil      | 'tar.gz'
        'madeup' | 'tar.gz'
        'tbz2'   | 'tar.bz2'
        'zip'    | 'zip'
      end
Robert Speicher's avatar
Robert Speicher committed
204

205 206 207 208 209
      with_them do
        it { expect(metadata['ArchivePrefix']).to eq(expected_prefix) }
        it { expect(metadata['ArchivePath']).to eq(expected_path) }
      end
    end
Robert Speicher's avatar
Robert Speicher committed
210 211
  end

212
  describe '#size' do
Robert Speicher's avatar
Robert Speicher committed
213 214 215 216 217
    subject { repository.size }

    it { is_expected.to be < 2 }
  end

218
  describe '#empty?' do
219
    it { expect(repository).not_to be_empty }
Robert Speicher's avatar
Robert Speicher committed
220 221
  end

222
  describe '#ref_names' do
Robert Speicher's avatar
Robert Speicher committed
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238
    let(:ref_names) { repository.ref_names }
    subject { ref_names }

    it { is_expected.to be_kind_of Array }

    describe '#first' do
      subject { super().first }
      it { is_expected.to eq('feature') }
    end

    describe '#last' do
      subject { super().last }
      it { is_expected.to eq('v1.2.1') }
    end
  end

239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
  describe '#submodule_url_for' do
    let(:ref) { 'master' }

    def submodule_url(path)
      repository.submodule_url_for(ref, path)
    end

    it { expect(submodule_url('six')).to eq('git://github.com/randx/six.git') }
    it { expect(submodule_url('nested/six')).to eq('git://github.com/randx/six.git') }
    it { expect(submodule_url('deeper/nested/six')).to eq('git://github.com/randx/six.git') }
    it { expect(submodule_url('invalid/path')).to eq(nil) }

    context 'uncommitted submodule dir' do
      let(:ref) { 'fix-existing-submodule-dir' }

      it { expect(submodule_url('submodule-existing-dir')).to eq(nil) }
    end

    context 'tags' do
      let(:ref) { 'v1.2.1' }

      it { expect(submodule_url('six')).to eq('git://github.com/randx/six.git') }
    end

263 264 265 266 267 268 269
    context 'no .gitmodules at commit' do
      let(:ref) { '9596bc54a6f0c0c98248fe97077eb5ccf48a98d0' }

      it { expect(submodule_url('six')).to eq(nil) }
    end

    context 'no gitlink entry' do
270 271 272 273 274 275
      let(:ref) { '6d39438' }

      it { expect(submodule_url('six')).to eq(nil) }
    end
  end

276
  describe '#commit_count' do
277 278 279
    it { expect(repository.commit_count("master")).to eq(25) }
    it { expect(repository.commit_count("feature")).to eq(9) }
    it { expect(repository.commit_count("does-not-exist")).to eq(0) }
280

281 282
    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::CommitService, :commit_count do
      subject { repository.commit_count('master') }
283
    end
Robert Speicher's avatar
Robert Speicher committed
284 285
  end

286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
  describe '#diverging_commit_count' do
    it 'counts 0 for the same branch' do
      expect(repository.diverging_commit_count('master', 'master', max_count: 1000)).to eq([0, 0])
    end

    context 'max count does not truncate results' do
      where(:left, :right, :expected) do
        1 | 1 | [1, 1]
        4 | 4 | [4, 4]
        2 | 2 | [2, 2]
        2 | 4 | [2, 4]
        4 | 2 | [4, 2]
        10 | 10 | [10, 10]
      end

      with_them do
        before do
          repository.create_branch('left-branch', 'master')
          repository.create_branch('right-branch', 'master')
305

306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
          left.times do
            new_commit_edit_new_file_on_branch(repository_rugged, 'encoding/CHANGELOG', 'left-branch', 'some more content for a', 'some stuff')
          end

          right.times do
            new_commit_edit_new_file_on_branch(repository_rugged, 'encoding/CHANGELOG', 'right-branch', 'some more content for b', 'some stuff')
          end
        end

        after do
          repository.delete_branch('left-branch')
          repository.delete_branch('right-branch')
        end

        it 'returns the correct count bounding at max_count' do
          branch_a_sha = repository_rugged.branches['left-branch'].target.oid
          branch_b_sha = repository_rugged.branches['right-branch'].target.oid
323 324 325 326

          count = repository.diverging_commit_count(branch_a_sha, branch_b_sha, max_count: 1000)

          expect(count).to eq(expected)
327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
        end
      end
    end

    context 'max count truncates results' do
      where(:left, :right, :max_count) do
        1 | 1 | 1
        4 | 4 | 4
        2 | 2 | 3
        2 | 4 | 3
        4 | 2 | 5
        10 | 10 | 10
      end

      with_them do
        before do
          repository.create_branch('left-branch', 'master')
          repository.create_branch('right-branch', 'master')
345

346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
          left.times do
            new_commit_edit_new_file_on_branch(repository_rugged, 'encoding/CHANGELOG', 'left-branch', 'some more content for a', 'some stuff')
          end

          right.times do
            new_commit_edit_new_file_on_branch(repository_rugged, 'encoding/CHANGELOG', 'right-branch', 'some more content for b', 'some stuff')
          end
        end

        after do
          repository.delete_branch('left-branch')
          repository.delete_branch('right-branch')
        end

        it 'returns the correct count bounding at max_count' do
          branch_a_sha = repository_rugged.branches['left-branch'].target.oid
          branch_b_sha = repository_rugged.branches['right-branch'].target.oid
363

364
          results = repository.diverging_commit_count(branch_a_sha, branch_b_sha, max_count: max_count)
365

366 367 368 369 370 371 372 373 374 375
          expect(results[0] + results[1]).to eq(max_count)
        end
      end
    end

    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::CommitService, :diverging_commit_count do
      subject { repository.diverging_commit_count('master', 'master', max_count: 1000) }
    end
  end

376
  describe '#has_local_branches?' do
377
    context 'check for local branches' do
378 379 380
      it { expect(repository.has_local_branches?).to eq(true) }

      context 'mutable' do
381
        let(:repository) { mutable_repository }
382 383 384 385 386 387 388

        after do
          ensure_seeds
        end

        it 'returns false when there are no branches' do
          # Sanity check
389
          expect(repository.has_local_branches?).to eq(true)
390

391 392
          FileUtils.rm_rf(File.join(repository_path, 'packed-refs'))
          heads_dir = File.join(repository_path, 'refs/heads')
393 394 395
          FileUtils.rm_rf(heads_dir)
          FileUtils.mkdir_p(heads_dir)

396
          repository.expire_has_local_branches_cache
397 398 399
          expect(repository.has_local_branches?).to eq(false)
        end
      end
400 401 402 403 404 405 406 407 408 409

      context 'memoizes the value' do
        it 'returns true' do
          expect(repository).to receive(:uncached_has_local_branches?).once.and_call_original

          2.times do
            expect(repository.has_local_branches?).to eq(true)
          end
        end
      end
410 411 412
    end
  end

Robert Speicher's avatar
Robert Speicher committed
413
  describe "#delete_branch" do
414
    let(:repository) { mutable_repository }
415

416 417 418
    after do
      ensure_seeds
    end
419

420 421
    it "removes the branch from the repo" do
      branch_name = "to-be-deleted-soon"
422

423 424
      repository.create_branch(branch_name)
      expect(repository_rugged.branches[branch_name]).not_to be_nil
Robert Speicher's avatar
Robert Speicher committed
425

426 427
      repository.delete_branch(branch_name)
      expect(repository_rugged.branches[branch_name]).to be_nil
Robert Speicher's avatar
Robert Speicher committed
428 429
    end

430 431 432 433
    context "when branch does not exist" do
      it "raises a DeleteBranchError exception" do
        expect { repository.delete_branch("this-branch-does-not-exist") }.to raise_error(Gitlab::Git::Repository::DeleteBranchError)
      end
Robert Speicher's avatar
Robert Speicher committed
434 435 436 437
    end
  end

  describe "#create_branch" do
438
    let(:repository) { mutable_repository }
Robert Speicher's avatar
Robert Speicher committed
439

440 441 442
    after do
      ensure_seeds
    end
443

444 445 446
    it "should create a new branch" do
      expect(repository.create_branch('new_branch', 'master')).not_to be_nil
    end
447

448 449
    it "should create a new branch with the right name" do
      expect(repository.create_branch('another_branch', 'master').name).to eq('another_branch')
Robert Speicher's avatar
Robert Speicher committed
450 451
    end

452 453 454
    it "should fail if we create an existing branch" do
      repository.create_branch('duplicated_branch', 'master')
      expect {repository.create_branch('duplicated_branch', 'master')}.to raise_error("Branch duplicated_branch already exists")
Robert Speicher's avatar
Robert Speicher committed
455 456
    end

457 458
    it "should fail if we create a branch from a non existing ref" do
      expect {repository.create_branch('branch_based_in_wrong_ref', 'master_2_the_revenge')}.to raise_error("Invalid reference master_2_the_revenge")
Robert Speicher's avatar
Robert Speicher committed
459 460 461
    end
  end

462
  describe '#delete_refs' do
463
    let(:repository) { mutable_repository }
464

465 466 467
    after do
      ensure_seeds
    end
468

469
    it 'deletes the ref' do
470
      repository.delete_refs('refs/heads/feature')
471

472
      expect(repository_rugged.references['refs/heads/feature']).to be_nil
473
    end
474

475 476
    it 'deletes all refs' do
      refs = %w[refs/heads/wip refs/tags/v1.1.0]
477
      repository.delete_refs(*refs)
478

479
      refs.each do |ref|
480
        expect(repository_rugged.references[ref]).to be_nil
481 482 483
      end
    end

484
    it 'does not fail when deleting an empty list of refs' do
485
      expect { repository.delete_refs(*[]) }.not_to raise_error
486 487
    end

488
    it 'raises an error if it failed' do
489
      expect { repository.delete_refs('refs\heads\fix') }.to raise_error(Gitlab::Git::Repository::GitError)
490 491 492
    end
  end

493
  describe '#branch_names_contains_sha' do
494
    let(:head_id) { repository_rugged.head.target.oid }
495 496
    let(:new_branch) { head_id }
    let(:utf8_branch) { 'branch-é' }
497

498 499 500
    before do
      repository.create_branch(new_branch, 'master')
      repository.create_branch(utf8_branch, 'master')
501 502
    end

503 504 505
    after do
      repository.delete_branch(new_branch)
      repository.delete_branch(utf8_branch)
506 507
    end

508 509
    it 'displays that branch' do
      expect(repository.branch_names_contains_sha(head_id)).to include('master', new_branch, utf8_branch)
510 511 512
    end
  end

Robert Speicher's avatar
Robert Speicher committed
513
  describe "#refs_hash" do
514
    subject { repository.refs_hash }
Robert Speicher's avatar
Robert Speicher committed
515 516 517 518

    it "should have as many entries as branches and tags" do
      expected_refs = SeedRepo::Repo::BRANCHES + SeedRepo::Repo::TAGS
      # We flatten in case a commit is pointed at by more than one branch and/or tag
519 520 521 522 523
      expect(subject.values.flatten.size).to eq(expected_refs.size)
    end

    it 'has valid commit ids as keys' do
      expect(subject.keys).to all( match(Commit::COMMIT_SHA_PATTERN) )
Robert Speicher's avatar
Robert Speicher committed
524 525 526
    end
  end

527
  describe '#fetch_repository_as_mirror' do
528
    let(:new_repository) do
529
      Gitlab::Git::Repository.new('default', 'my_project.git', '', 'group/project')
Robert Speicher's avatar
Robert Speicher committed
530 531
    end

532
    subject { new_repository.fetch_repository_as_mirror(repository) }
533 534

    before do
535
      Gitlab::Shell.new.create_repository('default', 'my_project', 'group/project')
Robert Speicher's avatar
Robert Speicher committed
536 537
    end

538
    after do
539
      Gitlab::Shell.new.remove_repository('default', 'my_project')
540 541
    end

542 543
    it 'fetches a repository as a mirror remote' do
      subject
544

545 546
      expect(refs(new_repository_path)).to eq(refs(repository_path))
    end
547

548 549 550 551
    context 'with keep-around refs' do
      let(:sha) { SeedRepo::Commit::ID }
      let(:keep_around_ref) { "refs/keep-around/#{sha}" }
      let(:tmp_ref) { "refs/tmp/#{SecureRandom.hex}" }
552

553 554 555
      before do
        repository_rugged.references.create(keep_around_ref, sha, force: true)
        repository_rugged.references.create(tmp_ref, sha, force: true)
556
      end
557

558 559
      it 'includes the temporary and keep-around refs' do
        subject
560

561 562 563
        expect(refs(new_repository_path)).to include(keep_around_ref)
        expect(refs(new_repository_path)).to include(tmp_ref)
      end
564
    end
565 566

    def new_repository_path
567
      File.join(TestEnv.repos_path, new_repository.relative_path)
568
    end
569 570
  end

571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591
  describe '#fetch_remote' do
    it 'delegates to the gitaly RepositoryService' do
      ssh_auth = double(:ssh_auth)
      expected_opts = {
        ssh_auth: ssh_auth,
        forced: true,
        no_tags: true,
        timeout: described_class::GITLAB_PROJECTS_TIMEOUT,
        prune: false
      }

      expect(repository.gitaly_repository_client).to receive(:fetch_remote).with('remote-name', expected_opts)

      repository.fetch_remote('remote-name', ssh_auth: ssh_auth, forced: true, no_tags: true, prune: false)
    end

    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RepositoryService, :fetch_remote do
      subject { repository.fetch_remote('remote-name') }
    end
  end

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
  describe '#search_files_by_content' do
    let(:repository) { mutable_repository }
    let(:repository_rugged) { mutable_repository_rugged }

    before do
      repository.create_branch('search-files-by-content-branch', 'master')
      new_commit_edit_new_file_on_branch(repository_rugged, 'encoding/CHANGELOG', 'search-files-by-content-branch', 'committing something', 'search-files-by-content change')
      new_commit_edit_new_file_on_branch(repository_rugged, 'anotherfile', 'search-files-by-content-branch', 'committing something', 'search-files-by-content change')
    end

    after do
      ensure_seeds
    end

    shared_examples 'search files by content' do
      it 'should have 2 items' do
        expect(search_results.size).to eq(2)
      end

      it 'should have the correct matching line' do
        expect(search_results).to contain_exactly("search-files-by-content-branch:encoding/CHANGELOG\u00001\u0000search-files-by-content change\n",
                                                  "search-files-by-content-branch:anotherfile\u00001\u0000search-files-by-content change\n")
      end
    end

    it_should_behave_like 'search files by content' do
      let(:search_results) do
        repository.search_files_by_content('search-files-by-content', 'search-files-by-content-branch')
      end
    end
  end

624 625 626 627 628 629 630 631
  describe '#find_remote_root_ref' do
    it 'gets the remote root ref from GitalyClient' do
      expect_any_instance_of(Gitlab::GitalyClient::RemoteService)
        .to receive(:find_remote_root_ref).and_call_original

      expect(repository.find_remote_root_ref('origin')).to eq 'master'
    end

632 633 634 635
    it 'returns UTF-8' do
      expect(repository.find_remote_root_ref('origin')).to be_utf8
    end

636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
    it 'returns nil when remote name is nil' do
      expect_any_instance_of(Gitlab::GitalyClient::RemoteService)
        .not_to receive(:find_remote_root_ref)

      expect(repository.find_remote_root_ref(nil)).to be_nil
    end

    it 'returns nil when remote name is empty' do
      expect_any_instance_of(Gitlab::GitalyClient::RemoteService)
        .not_to receive(:find_remote_root_ref)

      expect(repository.find_remote_root_ref('')).to be_nil
    end

    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RemoteService, :find_remote_root_ref do
      subject { repository.find_remote_root_ref('origin') }
    end
  end

Robert Speicher's avatar
Robert Speicher committed
655
  describe "#log" do
656 657
    shared_examples 'repository log' do
      let(:commit_with_old_name) do
658
        Gitlab::Git::Commit.find(repository, @commit_with_old_name_id)
659 660
      end
      let(:commit_with_new_name) do
661
        Gitlab::Git::Commit.find(repository, @commit_with_new_name_id)
662 663
      end
      let(:rename_commit) do
664
        Gitlab::Git::Commit.find(repository, @rename_commit_id)
665
      end
Robert Speicher's avatar
Robert Speicher committed
666

667
      before do
668
        # Add new commits so that there's a renamed file in the commit history
669 670
        @commit_with_old_name_id = new_commit_edit_old_file(repository_rugged).oid
        @rename_commit_id = new_commit_move_file(repository_rugged).oid
671
        @commit_with_new_name_id = new_commit_edit_new_file(repository_rugged, "encoding/CHANGELOG", "Edit encoding/CHANGELOG", "I'm a new changelog with different text").oid
672
      end
Robert Speicher's avatar
Robert Speicher committed
673

674
      after do
675
        # Erase our commits so other tests get the original repo
676
        repository_rugged.references.update("refs/heads/master", SeedRepo::LastCommit::ID)
Robert Speicher's avatar
Robert Speicher committed
677 678
      end

679 680 681 682 683 684
      context "where 'follow' == true" do
        let(:options) { { ref: "master", follow: true } }

        context "and 'path' is a directory" do
          it "does not follow renames" do
            log_commits = repository.log(options.merge(path: "encoding"))
685 686 687 688

            aggregate_failures do
              expect(log_commits).to include(commit_with_new_name)
              expect(log_commits).to include(rename_commit)
689
              expect(log_commits).not_to include(commit_with_old_name)
690
            end
691
          end
Robert Speicher's avatar
Robert Speicher committed
692 693
        end

694 695 696 697
        context "and 'path' is a file that matches the new filename" do
          context 'without offset' do
            it "follows renames" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG"))
698

699 700 701 702 703
              aggregate_failures do
                expect(log_commits).to include(commit_with_new_name)
                expect(log_commits).to include(rename_commit)
                expect(log_commits).to include(commit_with_old_name)
              end
704
            end
705 706
          end

707 708 709
          context 'with offset=1' do
            it "follows renames and skip the latest commit" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 1))
710

711 712 713 714 715 716
              aggregate_failures do
                expect(log_commits).not_to include(commit_with_new_name)
                expect(log_commits).to include(rename_commit)
                expect(log_commits).to include(commit_with_old_name)
              end
            end
717 718
          end

719 720 721
          context 'with offset=1', 'and limit=1' do
            it "follows renames, skip the latest commit and return only one commit" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 1, limit: 1))
722

723
              expect(log_commits).to contain_exactly(rename_commit)
724
            end
725 726
          end

727 728 729
          context 'with offset=1', 'and limit=2' do
            it "follows renames, skip the latest commit and return only two commits" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 1, limit: 2))
730

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753
              aggregate_failures do
                expect(log_commits).to contain_exactly(rename_commit, commit_with_old_name)
              end
            end
          end

          context 'with offset=2' do
            it "follows renames and skip the latest commit" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 2))

              aggregate_failures do
                expect(log_commits).not_to include(commit_with_new_name)
                expect(log_commits).not_to include(rename_commit)
                expect(log_commits).to include(commit_with_old_name)
              end
            end
          end

          context 'with offset=2', 'and limit=1' do
            it "follows renames, skip the two latest commit and return only one commit" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 2, limit: 1))

              expect(log_commits).to contain_exactly(commit_with_old_name)
754
            end
755 756
          end

757 758 759
          context 'with offset=2', 'and limit=2' do
            it "follows renames, skip the two latest commit and return only one commit" do
              log_commits = repository.log(options.merge(path: "encoding/CHANGELOG", offset: 2, limit: 2))
760

761 762 763 764 765 766
              aggregate_failures do
                expect(log_commits).not_to include(commit_with_new_name)
                expect(log_commits).not_to include(rename_commit)
                expect(log_commits).to include(commit_with_old_name)
              end
            end
767 768 769
          end
        end

770 771 772
        context "and 'path' is a file that matches the old filename" do
          it "does not follow renames" do
            log_commits = repository.log(options.merge(path: "CHANGELOG"))
773 774 775

            aggregate_failures do
              expect(log_commits).not_to include(commit_with_new_name)
776
              expect(log_commits).to include(rename_commit)
777 778
              expect(log_commits).to include(commit_with_old_name)
            end
779
          end
Robert Speicher's avatar
Robert Speicher committed
780 781
        end

782 783 784
        context "unknown ref" do
          it "returns an empty array" do
            log_commits = repository.log(options.merge(ref: 'unknown'))
Robert Speicher's avatar
Robert Speicher committed
785

786
            expect(log_commits).to eq([])
787
          end
Robert Speicher's avatar
Robert Speicher committed
788 789 790
        end
      end

791 792
      context "where 'follow' == false" do
        options = { follow: false }
Robert Speicher's avatar
Robert Speicher committed
793

794 795 796 797
        context "and 'path' is a directory" do
          let(:log_commits) do
            repository.log(options.merge(path: "encoding"))
          end
Robert Speicher's avatar
Robert Speicher committed
798

799 800 801 802 803
          it "does not follow renames" do
            expect(log_commits).to include(commit_with_new_name)
            expect(log_commits).to include(rename_commit)
            expect(log_commits).not_to include(commit_with_old_name)
          end
Robert Speicher's avatar
Robert Speicher committed
804 805
        end

806 807 808 809
        context "and 'path' is a file that matches the new filename" do
          let(:log_commits) do
            repository.log(options.merge(path: "encoding/CHANGELOG"))
          end
Robert Speicher's avatar
Robert Speicher committed
810

811 812 813 814 815
          it "does not follow renames" do
            expect(log_commits).to include(commit_with_new_name)
            expect(log_commits).to include(rename_commit)
            expect(log_commits).not_to include(commit_with_old_name)
          end
Robert Speicher's avatar
Robert Speicher committed
816 817
        end

818 819 820 821
        context "and 'path' is a file that matches the old filename" do
          let(:log_commits) do
            repository.log(options.merge(path: "CHANGELOG"))
          end
Robert Speicher's avatar
Robert Speicher committed
822

823 824 825 826 827
          it "does not follow renames" do
            expect(log_commits).to include(commit_with_old_name)
            expect(log_commits).to include(rename_commit)
            expect(log_commits).not_to include(commit_with_new_name)
          end
Robert Speicher's avatar
Robert Speicher committed
828 829
        end

830 831 832 833 834 835 836 837
        context "and 'path' includes a directory that used to be a file" do
          let(:log_commits) do
            repository.log(options.merge(ref: "refs/heads/fix-blob-path", path: "files/testdir/file.txt"))
          end

          it "returns a list of commits" do
            expect(log_commits.size).to eq(1)
          end
Robert Speicher's avatar
Robert Speicher committed
838 839 840
        end
      end

841 842
      context "where provides 'after' timestamp" do
        options = { after: Time.iso8601('2014-03-03T20:15:01+00:00') }
Robert Speicher's avatar
Robert Speicher committed
843

844 845 846 847 848 849 850
        it "should returns commits on or after that timestamp" do
          commits = repository.log(options)

          expect(commits.size).to be > 0
          expect(commits).to satisfy do |commits|
            commits.all? { |commit| commit.committed_date >= options[:after] }
          end
Robert Speicher's avatar
Robert Speicher committed
851 852 853
        end
      end

854 855
      context "where provides 'before' timestamp" do
        options = { before: Time.iso8601('2014-03-03T20:15:01+00:00') }
Robert Speicher's avatar
Robert Speicher committed
856

857 858
        it "should returns commits on or before that timestamp" do
          commits = repository.log(options)
Robert Speicher's avatar
Robert Speicher committed
859

860 861 862 863
          expect(commits.size).to be > 0
          expect(commits).to satisfy do |commits|
            commits.all? { |commit| commit.committed_date <= options[:before] }
          end
Robert Speicher's avatar
Robert Speicher committed
864 865 866
        end
      end

867 868
      context 'when multiple paths are provided' do
        let(:options) { { ref: 'master', path: ['PROCESS.md', 'README.md'] } }
Robert Speicher's avatar
Robert Speicher committed
869

870
        def commit_files(commit)
871
          Gitlab::GitalyClient::StorageSettings.allow_disk_access do
872 873
            commit.deltas.flat_map do |delta|
              [delta.old_path, delta.new_path].uniq.compact
874
            end
875
          end
876 877
        end

878 879
        it 'only returns commits matching at least one path' do
          commits = repository.log(options)
880

881 882 883 884
          expect(commits.size).to be > 0
          expect(commits).to satisfy do |commits|
            commits.none? { |commit| (commit_files(commit) & options[:path]).empty? }
          end
885 886 887
        end
      end

888 889 890 891
      context 'limit validation' do
        where(:limit) do
          [0, nil, '', 'foo']
        end
892

893 894
        with_them do
          it { expect { repository.log(limit: limit) }.to raise_error(ArgumentError) }
Robert Speicher's avatar
Robert Speicher committed
895 896
        end
      end
897

898 899 900
      context 'with all' do
        it 'returns a list of commits' do
          commits = repository.log({ all: true, limit: 50 })
901

902 903
          expect(commits.size).to eq(37)
        end
904 905
      end
    end
Tiago Botelho's avatar
Tiago Botelho committed
906

907 908 909
    context 'when Gitaly find_commits feature is enabled' do
      it_behaves_like 'repository log'
    end
Robert Speicher's avatar
Robert Speicher committed
910 911 912 913 914 915 916 917
  end

  describe '#count_commits_between' do
    subject { repository.count_commits_between('feature', 'master') }

    it { is_expected.to eq(17) }
  end

Rubén Dávila's avatar
Rubén Dávila committed
918
  describe '#raw_changes_between' do
919 920 921
    let(:old_rev) { }
    let(:new_rev) { }
    let(:changes) { repository.raw_changes_between(old_rev, new_rev) }
Rubén Dávila's avatar
Rubén Dávila committed
922

923 924 925
    context 'initial commit' do
      let(:old_rev) { Gitlab::Git::BLANK_SHA }
      let(:new_rev) { '1a0b36b3cdad1d2ee32457c102a8c0b7056fa863' }
Rubén Dávila's avatar
Rubén Dávila committed
926

927 928 929
      it 'returns the changes' do
        expect(changes).to be_present
        expect(changes.size).to eq(3)
Rubén Dávila's avatar
Rubén Dávila committed
930
      end
931
    end
Rubén Dávila's avatar
Rubén Dávila committed
932

933 934 935
    context 'with an invalid rev' do
      let(:old_rev) { 'foo' }
      let(:new_rev) { 'bar' }
Rubén Dávila's avatar
Rubén Dávila committed
936

937 938
      it 'returns an error' do
        expect { changes }.to raise_error(Gitlab::Git::Repository::GitError)
Rubén Dávila's avatar
Rubén Dávila committed
939 940 941
      end
    end

942 943 944
    context 'with valid revs' do
      let(:old_rev) { 'fa1b1e6c004a68b7d8763b86455da9e6b23e36d6' }
      let(:new_rev) { '4b4918a572fa86f9771e5ba40fbd48e1eb03e2c6' }
Rubén Dávila's avatar
Rubén Dávila committed
945

946 947 948 949 950 951 952
      it 'returns the changes' do
        expect(changes.size).to eq(9)
        expect(changes.first.operation).to eq(:modified)
        expect(changes.first.new_path).to eq('.gitmodules')
        expect(changes.last.operation).to eq(:added)
        expect(changes.last.new_path).to eq('files/lfs/picture-invalid.png')
      end
Rubén Dávila's avatar
Rubén Dávila committed
953 954 955
    end
  end

956
  describe '#merge_base' do
957 958 959 960 961
    where(:from, :to, :result) do
      '570e7b2abdd848b95f2f578043fc23bd6f6fd24d' | '40f4a7a617393735a95a0bb67b08385bc1e7c66d' | '570e7b2abdd848b95f2f578043fc23bd6f6fd24d'
      '40f4a7a617393735a95a0bb67b08385bc1e7c66d' | '570e7b2abdd848b95f2f578043fc23bd6f6fd24d' | '570e7b2abdd848b95f2f578043fc23bd6f6fd24d'
      '40f4a7a617393735a95a0bb67b08385bc1e7c66d' | 'foobar' | nil
      'foobar' | '40f4a7a617393735a95a0bb67b08385bc1e7c66d' | nil
962 963
    end

964 965
    with_them do
      it { expect(repository.merge_base(from, to)).to eq(result) }
966 967 968
    end
  end

969
  describe '#count_commits' do
970
    describe 'extended commit counting' do
971 972
      context 'with after timestamp' do
        it 'returns the number of commits after timestamp' do
973
          options = { ref: 'master', after: Time.iso8601('2013-03-03T20:15:01+00:00') }
974

975 976
          expect(repository.count_commits(options)).to eq(25)
        end
977 978
      end

979 980
      context 'with before timestamp' do
        it 'returns the number of commits before timestamp' do
981
          options = { ref: 'feature', before: Time.iso8601('2015-03-03T20:15:01+00:00') }
982

983 984
          expect(repository.count_commits(options)).to eq(9)
        end
985 986
      end

987 988 989 990 991 992 993 994
      context 'with max_count' do
        it 'returns the number of commits with path ' do
          options = { ref: 'master', max_count: 5 }

          expect(repository.count_commits(options)).to eq(5)
        end
      end

995 996
      context 'with path' do
        it 'returns the number of commits with path ' do
997 998 999 1000 1001 1002 1003 1004 1005
          options = { ref: 'master', path: 'encoding' }

          expect(repository.count_commits(options)).to eq(2)
        end
      end

      context 'with option :from and option :to' do
        it 'returns the number of commits ahead for fix-mode..fix-blob-path' do
          options = { from: 'fix-mode', to: 'fix-blob-path' }
1006

1007 1008
          expect(repository.count_commits(options)).to eq(2)
        end
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030

        it 'returns the number of commits ahead for fix-blob-path..fix-mode' do
          options = { from: 'fix-blob-path', to: 'fix-mode' }

          expect(repository.count_commits(options)).to eq(1)
        end

        context 'with option :left_right' do
          it 'returns the number of commits for fix-mode...fix-blob-path' do
            options = { from: 'fix-mode', to: 'fix-blob-path', left_right: true }

            expect(repository.count_commits(options)).to eq([1, 2])
          end

          context 'with max_count' do
            it 'returns the number of commits with path ' do
              options = { from: 'fix-mode', to: 'fix-blob-path', left_right: true, max_count: 1 }

              expect(repository.count_commits(options)).to eq([1, 1])
            end
          end
        end
1031
      end
1032 1033 1034 1035 1036 1037 1038 1039

      context 'with max_count' do
        it 'returns the number of commits up to the passed limit' do
          options = { ref: 'master', max_count: 10, after: Time.iso8601('2013-03-03T20:15:01+00:00') }

          expect(repository.count_commits(options)).to eq(10)
        end
      end
Tiago Botelho's avatar
Tiago Botelho committed
1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050

      context "with all" do
        it "returns the number of commits in the whole repository" do
          options = { all: true }

          expect(repository.count_commits(options)).to eq(34)
        end
      end

      context 'without all or ref being specified' do
        it "raises an ArgumentError" do
1051
          expect { repository.count_commits({}) }.to raise_error(ArgumentError)
Tiago Botelho's avatar
Tiago Botelho committed
1052 1053
        end
      end
1054
    end
1055 1056
  end

Robert Speicher's avatar
Robert Speicher committed
1057
  describe '#find_branch' do
Jacob Vosmaer's avatar
Jacob Vosmaer committed
1058 1059
    it 'should return a Branch for master' do
      branch = repository.find_branch('master')
Robert Speicher's avatar
Robert Speicher committed
1060

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1061 1062 1063
      expect(branch).to be_a_kind_of(Gitlab::Git::Branch)
      expect(branch.name).to eq('master')
    end
Robert Speicher's avatar
Robert Speicher committed
1064

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1065 1066
    it 'should handle non-existent branch' do
      branch = repository.find_branch('this-is-garbage')
Robert Speicher's avatar
Robert Speicher committed
1067

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1068 1069
      expect(branch).to eq(nil)
    end
1070 1071
  end

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
  describe '#ref_name_for_sha' do
    let(:ref_path) { 'refs/heads' }
    let(:sha) { repository.find_branch('master').dereferenced_target.id }
    let(:ref_name) { 'refs/heads/master' }

    it 'returns the ref name for the given sha' do
      expect(repository.ref_name_for_sha(ref_path, sha)).to eq(ref_name)
    end

    it "returns an empty name if the ref doesn't exist" do
      expect(repository.ref_name_for_sha(ref_path, "000000")).to eq("")
    end

    it "raise an exception if the ref is empty" do
      expect { repository.ref_name_for_sha(ref_path, "") }.to raise_error(ArgumentError)
    end

    it "raise an exception if the ref is nil" do
      expect { repository.ref_name_for_sha(ref_path, nil) }.to raise_error(ArgumentError)
    end
  end

1094 1095 1096 1097
  describe '#branches' do
    subject { repository.branches }

    context 'with local and remote branches' do
1098
      let(:repository) { mutable_repository }
1099 1100

      before do
1101
        create_remote_branch('joe', 'remote_branch', 'master')
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
        repository.create_branch('local_branch', 'master')
      end

      after do
        ensure_seeds
      end

      it 'returns the local and remote branches' do
        expect(subject.any? { |b| b.name == 'joe/remote_branch' }).to eq(true)
        expect(subject.any? { |b| b.name == 'local_branch' }).to eq(true)
      end
Robert Speicher's avatar
Robert Speicher committed
1113
    end
1114 1115

    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :branches
Robert Speicher's avatar
Robert Speicher committed
1116 1117 1118 1119
  end

  describe '#branch_count' do
    it 'returns the number of branches' do
1120
      expect(repository.branch_count).to eq(11)
Robert Speicher's avatar
Robert Speicher committed
1121
    end
1122 1123

    context 'with local and remote branches' do
1124
      let(:repository) { mutable_repository }
1125 1126

      before do
1127
        create_remote_branch('joe', 'remote_branch', 'master')
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
        repository.create_branch('local_branch', 'master')
      end

      after do
        ensure_seeds
      end

      it 'returns the count of local branches' do
        expect(repository.branch_count).to eq(repository.local_branches.count)
      end

      context 'with Gitaly disabled' do
        before do
          allow(Gitlab::GitalyClient).to receive(:feature_enabled?).and_return(false)
        end

        it 'returns the count of local branches' do
          expect(repository.branch_count).to eq(repository.local_branches.count)
        end
      end
    end
Robert Speicher's avatar
Robert Speicher committed
1149 1150
  end

1151
  describe '#merged_branch_names' do
1152 1153 1154
    context 'when branch names are passed' do
      it 'only returns the names we are asking' do
        names = repository.merged_branch_names(%w[merge-test])
1155

1156 1157
        expect(names).to contain_exactly('merge-test')
      end
1158

1159 1160
      it 'does not return unmerged branch names' do
        names = repository.merged_branch_names(%w[feature])
1161

1162
        expect(names).to be_empty
1163
      end
1164
    end
1165

1166 1167 1168
    context 'when no root ref is available' do
      it 'returns empty list' do
        project = create(:project, :empty_repo)
1169

1170
        names = project.repository.merged_branch_names(%w[feature])
1171

1172
        expect(names).to be_empty
1173
      end
1174
    end
1175

1176 1177 1178 1179
    context 'when no branch names are specified' do
      before do
        repository.create_branch('identical', 'master')
      end
1180

1181 1182
      after do
        ensure_seeds
1183
      end
1184

1185 1186
      it 'returns all merged branch names except for identical one' do
        names = repository.merged_branch_names
1187

1188 1189 1190 1191 1192
        expect(names).to include('merge-test')
        expect(names).to include('fix-mode')
        expect(names).not_to include('feature')
        expect(names).not_to include('identical')
      end
1193
    end
1194 1195
  end

1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
  describe '#diff_stats' do
    let(:left_commit_id) { 'feature' }
    let(:right_commit_id) { 'master' }

    it 'returns a DiffStatsCollection' do
      collection = repository.diff_stats(left_commit_id, right_commit_id)

      expect(collection).to be_a(Gitlab::Git::DiffStatsCollection)
      expect(collection).to be_a(Enumerable)
    end

    it 'yields Gitaly::DiffStats objects' do
      collection = repository.diff_stats(left_commit_id, right_commit_id)

      expect(collection.to_a).to all(be_a(Gitaly::DiffStats))
    end

    it 'returns no Gitaly::DiffStats when SHAs are invalid' do
      collection = repository.diff_stats('foo', 'bar')

      expect(collection).to be_a(Gitlab::Git::DiffStatsCollection)
      expect(collection).to be_a(Enumerable)
      expect(collection.to_a).to be_empty
    end
1220 1221

    it 'returns no Gitaly::DiffStats when there is a nil SHA' do
1222 1223 1224
      expect_any_instance_of(Gitlab::GitalyClient::CommitService)
        .not_to receive(:diff_stats)

1225 1226 1227 1228 1229 1230
      collection = repository.diff_stats(nil, 'master')

      expect(collection).to be_a(Gitlab::Git::DiffStatsCollection)
      expect(collection).to be_a(Enumerable)
      expect(collection.to_a).to be_empty
    end
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241

    it 'returns no Gitaly::DiffStats when there is a BLANK_SHA' do
      expect_any_instance_of(Gitlab::GitalyClient::CommitService)
        .not_to receive(:diff_stats)

      collection = repository.diff_stats(Gitlab::Git::BLANK_SHA, 'master')

      expect(collection).to be_a(Gitlab::Git::DiffStatsCollection)
      expect(collection).to be_a(Enumerable)
      expect(collection.to_a).to be_empty
    end
1242 1243
  end

Robert Speicher's avatar
Robert Speicher committed
1244 1245
  describe "#ls_files" do
    let(:master_file_paths) { repository.ls_files("master") }
1246
    let(:utf8_file_paths) { repository.ls_files("ls-files-utf8") }
Robert Speicher's avatar
Robert Speicher committed
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
    let(:not_existed_branch) { repository.ls_files("not_existed_branch") }

    it "read every file paths of master branch" do
      expect(master_file_paths.length).to equal(40)
    end

    it "reads full file paths of master branch" do
      expect(master_file_paths).to include("files/html/500.html")
    end

1257
    it "does not read submodule directory and empty directory of master branch" do
Robert Speicher's avatar
Robert Speicher committed
1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
      expect(master_file_paths).not_to include("six")
    end

    it "does not include 'nil'" do
      expect(master_file_paths).not_to include(nil)
    end

    it "returns empty array when not existed branch" do
      expect(not_existed_branch.length).to equal(0)
    end
1268 1269 1270 1271

    it "returns valid utf-8 data" do
      expect(utf8_file_paths.map { |file| file.force_encoding('utf-8') }).to all(be_valid_encoding)
    end
Robert Speicher's avatar
Robert Speicher committed
1272 1273 1274
  end

  describe "#copy_gitattributes" do
Jacob Vosmaer's avatar
Jacob Vosmaer committed
1275
    let(:attributes_path) { File.join(SEED_STORAGE_PATH, TEST_REPO_PATH, 'info/attributes') }
Robert Speicher's avatar
Robert Speicher committed
1276

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1277 1278 1279
    after do
      FileUtils.rm_rf(attributes_path) if Dir.exist?(attributes_path)
    end
Robert Speicher's avatar
Robert Speicher committed
1280

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1281 1282 1283
    it "raises an error with invalid ref" do
      expect { repository.copy_gitattributes("invalid") }.to raise_error(Gitlab::Git::Repository::InvalidRef)
    end
Robert Speicher's avatar
Robert Speicher committed
1284

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1285 1286
    context 'when forcing encoding issues' do
      let(:branch_name) { "ʕ•ᴥ•ʔ" }
Robert Speicher's avatar
Robert Speicher committed
1287

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1288 1289 1290
      before do
        repository.create_branch(branch_name, "master")
      end
Robert Speicher's avatar
Robert Speicher committed
1291

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1292 1293
      after do
        repository.rm_branch(branch_name, user: build(:admin))
Robert Speicher's avatar
Robert Speicher committed
1294 1295
      end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1296 1297
      it "doesn't raise with a valid unicode ref" do
        expect { repository.copy_gitattributes(branch_name) }.not_to raise_error
Robert Speicher's avatar
Robert Speicher committed
1298

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1299
        repository
Robert Speicher's avatar
Robert Speicher committed
1300
      end
Jacob Vosmaer's avatar
Jacob Vosmaer committed
1301
    end
Robert Speicher's avatar
Robert Speicher committed
1302

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1303 1304 1305 1306
    context "with no .gitattrbutes" do
      before do
        repository.copy_gitattributes("master")
      end
Robert Speicher's avatar
Robert Speicher committed
1307

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1308 1309 1310 1311
      it "does not have an info/attributes" do
        expect(File.exist?(attributes_path)).to be_falsey
      end
    end
Robert Speicher's avatar
Robert Speicher committed
1312

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1313 1314 1315
    context "with .gitattrbutes" do
      before do
        repository.copy_gitattributes("gitattributes")
Robert Speicher's avatar
Robert Speicher committed
1316 1317
      end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1318 1319 1320
      it "has an info/attributes" do
        expect(File.exist?(attributes_path)).to be_truthy
      end
1321

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1322 1323 1324 1325 1326
      it "has the same content in info/attributes as .gitattributes" do
        contents = File.open(attributes_path, "rb") { |f| f.read }
        expect(contents).to eq("*.md binary\n")
      end
    end
1327

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1328 1329 1330 1331
    context "with updated .gitattrbutes" do
      before do
        repository.copy_gitattributes("gitattributes")
        repository.copy_gitattributes("gitattributes-updated")
Robert Speicher's avatar
Robert Speicher committed
1332 1333
      end

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1334 1335 1336
      it "has an info/attributes" do
        expect(File.exist?(attributes_path)).to be_truthy
      end
1337

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1338 1339 1340
      it "has the updated content in info/attributes" do
        contents = File.read(attributes_path)
        expect(contents).to eq("*.txt binary\n")
Robert Speicher's avatar
Robert Speicher committed
1341 1342
      end
    end
1343

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1344 1345 1346 1347 1348
    context "with no .gitattrbutes in HEAD but with previous info/attributes" do
      before do
        repository.copy_gitattributes("gitattributes")
        repository.copy_gitattributes("master")
      end
1349

Jacob Vosmaer's avatar
Jacob Vosmaer committed
1350 1351 1352
      it "does not have an info/attributes" do
        expect(File.exist?(attributes_path)).to be_falsey
      end
1353
    end
Robert Speicher's avatar
Robert Speicher committed
1354 1355
  end

1356
  describe '#gitattribute' do
1357
    let(:repository) { Gitlab::Git::Repository.new('default', TEST_GITATTRIBUTES_REPO_PATH, '', 'group/project') }
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375

    after do
      ensure_seeds
    end

    it 'returns matching language attribute' do
      expect(repository.gitattribute("custom-highlighting/test.gitlab-custom", 'gitlab-language')).to eq('ruby')
    end

    it 'returns matching language attribute with additional options' do
      expect(repository.gitattribute("custom-highlighting/test.gitlab-cgi", 'gitlab-language')).to eq('erb?parent=json')
    end

    it 'returns nil if nothing matches' do
      expect(repository.gitattribute("report.xslt", 'gitlab-language')).to eq(nil)
    end

    context 'without gitattributes file' do
1376
      let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
1377 1378 1379 1380 1381 1382 1383

      it 'returns nil' do
        expect(repository.gitattribute("README.md", 'gitlab-language')).to eq(nil)
      end
    end
  end

1384
  describe '#ref_exists?' do
1385 1386 1387
    it 'returns true for an existing tag' do
      expect(repository.ref_exists?('refs/heads/master')).to eq(true)
    end
1388

1389 1390
    it 'returns false for a non-existing tag' do
      expect(repository.ref_exists?('refs/tags/THIS_TAG_DOES_NOT_EXIST')).to eq(false)
1391 1392
    end

1393 1394
    it 'raises an ArgumentError for an empty string' do
      expect { repository.ref_exists?('') }.to raise_error(ArgumentError)
1395 1396
    end

1397 1398
    it 'raises an ArgumentError for an invalid ref' do
      expect { repository.ref_exists?('INVALID') }.to raise_error(ArgumentError)
1399 1400 1401
    end
  end

Robert Speicher's avatar
Robert Speicher committed
1402
  describe '#tag_exists?' do
1403 1404
    it 'returns true for an existing tag' do
      tag = repository.tag_names.first
1405

1406
      expect(repository.tag_exists?(tag)).to eq(true)
1407 1408
    end

1409 1410
    it 'returns false for a non-existing tag' do
      expect(repository.tag_exists?('v9000')).to eq(false)
Robert Speicher's avatar
Robert Speicher committed
1411 1412 1413 1414
    end
  end

  describe '#branch_exists?' do
1415 1416
    it 'returns true for an existing branch' do
      expect(repository.branch_exists?('master')).to eq(true)
Robert Speicher's avatar
Robert Speicher committed
1417 1418
    end

1419 1420
    it 'returns false for a non-existing branch' do
      expect(repository.branch_exists?('kittens')).to eq(false)
Robert Speicher's avatar
Robert Speicher committed
1421 1422
    end

1423 1424
    it 'returns false when using an invalid branch name' do
      expect(repository.branch_exists?('.bla')).to eq(false)
Robert Speicher's avatar
Robert Speicher committed
1425 1426 1427 1428
    end
  end

  describe '#local_branches' do
1429 1430 1431 1432 1433
    let(:repository) { mutable_repository }

    before do
      create_remote_branch('joe', 'remote_branch', 'master')
      repository.create_branch('local_branch', 'master')
Robert Speicher's avatar
Robert Speicher committed
1434 1435
    end

1436
    after do
Robert Speicher's avatar
Robert Speicher committed
1437 1438 1439 1440
      ensure_seeds
    end

    it 'returns the local branches' do
1441 1442
      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)
Robert Speicher's avatar
Robert Speicher committed
1443
    end
1444

1445
    it 'returns a Branch with UTF-8 fields' do
1446
      branches = repository.local_branches.to_a
1447 1448
      expect(branches.size).to be > 0
      branches.each do |branch|
1449 1450
        expect(branch.name).to be_utf8
        expect(branch.target).to be_utf8 unless branch.target.nil?
1451
      end
1452
    end
1453

1454
    it 'gets the branches from GitalyClient' do
Andrew Newdigate's avatar
Andrew Newdigate committed
1455
      expect_any_instance_of(Gitlab::GitalyClient::RefService).to receive(:local_branches)
1456
        .and_return([])
1457
      repository.local_branches
1458
    end
1459

Andrew Newdigate's avatar
Andrew Newdigate committed
1460
    it_behaves_like 'wrapping gRPC errors', Gitlab::GitalyClient::RefService, :local_branches do
1461
      subject { repository.local_branches }
1462
    end
Robert Speicher's avatar
Robert Speicher committed
1463 1464
  end

1465
  describe '#languages' do
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
    it 'returns exactly the expected results' do
      languages = repository.languages('4b4918a572fa86f9771e5ba40fbd48e1eb03e2c6')
      expected_languages = [
        { value: 66.63, label: "Ruby", color: "#701516", highlight: "#701516" },
        { value: 22.96, label: "JavaScript", color: "#f1e05a", highlight: "#f1e05a" },
        { value: 7.9, label: "HTML", color: "#e34c26", highlight: "#e34c26" },
        { value: 2.51, label: "CoffeeScript", color: "#244776", highlight: "#244776" }
      ]

      expect(languages.size).to eq(expected_languages.size)

      expected_languages.size.times do |i|
        a = expected_languages[i]
        b = languages[i]
1480

1481 1482
        expect(a.keys.sort).to eq(b.keys.sort)
        expect(a[:value]).to be_within(0.1).of(b[:value])
1483

1484 1485
        non_float_keys = a.keys - [:value]
        expect(a.values_at(*non_float_keys)).to eq(b.values_at(*non_float_keys))
1486 1487 1488
      end
    end

1489 1490
    it "uses the repository's HEAD when no ref is passed" do
      lang = repository.languages.first
1491

1492
      expect(lang[:label]).to eq('Ruby')
1493 1494 1495
    end
  end

1496
  describe '#license_short_name' do
1497
    subject { repository.license_short_name }
1498

1499 1500 1501
    context 'when no license file can be found' do
      let(:project) { create(:project, :repository) }
      let(:repository) { project.repository.raw_repository }
1502

1503 1504
      before do
        project.repository.delete_file(project.owner, 'LICENSE', message: 'remove license', branch_name: 'master')
1505 1506
      end

1507
      it { is_expected.to be_nil }
1508 1509
    end

1510 1511
    context 'when an mit license is found' do
      it { is_expected.to eq('mit') }
1512 1513 1514
    end
  end

1515
  describe '#fetch_source_branch!' do
1516
    let(:local_ref) { 'refs/merge-requests/1/head' }
1517
    let(:source_repository) { mutable_repository }
1518

1519 1520 1521
    after do
      ensure_seeds
    end
1522

1523 1524 1525
    context 'when the branch exists' do
      context 'when the commit does not exist locally' do
        let(:source_branch) { 'new-branch-for-fetch-source-branch' }
1526 1527
        let(:source_path) { File.join(TestEnv.repos_path, source_repository.relative_path) }
        let(:source_rugged) { Rugged::Repository.new(source_path) }
1528
        let(:new_oid) { new_commit_edit_old_file(source_rugged).oid }
1529

1530 1531
        before do
          source_rugged.branches.create(source_branch, new_oid)
1532
        end
1533

1534 1535 1536
        it 'writes the ref' do
          expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(true)
          expect(repository.commit(local_ref).sha).to eq(new_oid)
1537
        end
1538 1539
      end

1540 1541 1542 1543 1544 1545 1546
      context 'when the commit exists locally' do
        let(:source_branch) { 'master' }
        let(:expected_oid) { SeedRepo::LastCommit::ID }

        it 'writes the ref' do
          # Sanity check: the commit should already exist
          expect(repository.commit(expected_oid)).not_to be_nil
1547

1548 1549
          expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(true)
          expect(repository.commit(local_ref).sha).to eq(expected_oid)
1550
        end
1551 1552
      end
    end
1553

1554 1555
    context 'when the branch does not exist' do
      let(:source_branch) { 'definitely-not-master' }
1556

1557 1558 1559 1560
      it 'does not write the ref' do
        expect(repository.fetch_source_branch!(source_repository, source_branch, local_ref)).to eq(false)
        expect(repository.commit(local_ref)).to be_nil
      end
1561
    end
1562 1563
  end

1564
  describe '#rm_branch' do
1565 1566 1567
    let(:project) { create(:project, :repository) }
    let(:repository) { project.repository.raw }
    let(:branch_name) { "to-be-deleted-soon" }
1568

1569 1570 1571
    before do
      project.add_developer(user)
      repository.create_branch(branch_name)
1572 1573
    end

1574 1575
    it "removes the branch from the repo" do
      repository.rm_branch(branch_name, user: user)
1576

1577
      expect(repository_rugged.branches[branch_name]).to be_nil
1578 1579 1580
    end
  end

1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
  describe '#write_ref' do
    context 'validations' do
      using RSpec::Parameterized::TableSyntax

      where(:ref_path, :ref) do
        'foo bar' | '123'
        'foobar'  | "12\x003"
      end

      with_them do
        it 'raises ArgumentError' do
          expect { repository.write_ref(ref_path, ref) }.to raise_error(ArgumentError)
        end
      end
    end
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608

    it 'writes the HEAD' do
      repository.write_ref('HEAD', 'refs/heads/feature')

      expect(repository.commit('HEAD')).to eq(repository.commit('feature'))
      expect(repository.root_ref).to eq('feature')
    end

    it 'writes other refs' do
      repository.write_ref('refs/heads/feature', SeedRepo::Commit::ID)

      expect(repository.commit('feature').sha).to eq(SeedRepo::Commit::ID)
    end
1609 1610
  end

1611 1612
  describe '#write_config' do
    before do
1613
      repository_rugged.config["gitlab.fullpath"] = repository_path
1614 1615
    end

1616 1617 1618
    context 'is given a path' do
      it 'writes it to disk' do
        repository.write_config(full_path: "not-the/real-path.git")
1619

1620
        config = File.read(File.join(repository_path, "config"))
1621

1622 1623
        expect(config).to include("[gitlab]")
        expect(config).to include("fullpath = not-the/real-path.git")
1624
      end
1625
    end
1626

1627 1628 1629
    context 'it is given an empty path' do
      it 'does not write it to disk' do
        repository.write_config(full_path: "")
1630

1631
        config = File.read(File.join(repository_path, "config"))
1632

1633 1634
        expect(config).to include("[gitlab]")
        expect(config).to include("fullpath = #{repository_path}")
1635
      end
1636
    end
1637

1638 1639
    context 'repository does not exist' do
      it 'raises NoRepository and does not call Gitaly WriteConfig' do
1640
        repository = Gitlab::Git::Repository.new('default', 'does/not/exist.git', '', 'group/project')
1641

1642
        expect(repository.gitaly_repository_client).not_to receive(:write_config)
1643

1644 1645 1646
        expect do
          repository.write_config(full_path: 'foo/bar.git')
        end.to raise_error(Gitlab::Git::Repository::NoRepository)
1647
      end
1648 1649 1650
    end
  end

1651
  describe '#set_config' do
1652
    let(:repository) { mutable_repository }
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
    let(:entries) do
      {
        'test.foo1' => 'bla bla',
        'test.foo2' => 1234,
        'test.foo3' => true
      }
    end

    it 'can set config settings' do
      expect(repository.set_config(entries)).to be_nil

1664 1665 1666
      expect(repository_rugged.config['test.foo1']).to eq('bla bla')
      expect(repository_rugged.config['test.foo2']).to eq('1234')
      expect(repository_rugged.config['test.foo3']).to eq('true')
1667 1668 1669
    end

    after do
1670
      entries.keys.each { |k| repository_rugged.config.delete(k) }
1671 1672 1673 1674
    end
  end

  describe '#delete_config' do
1675
    let(:repository) { mutable_repository }
1676 1677 1678 1679 1680 1681 1682 1683 1684 1685
    let(:entries) do
      {
        'test.foo1' => 'bla bla',
        'test.foo2' => 1234,
        'test.foo3' => true
      }
    end

    it 'can delete config settings' do
      entries.each do |key, value|
1686
        repository_rugged.config[key] = value
1687 1688 1689 1690
      end

      expect(repository.delete_config(*%w[does.not.exist test.foo1 test.foo2])).to be_nil

1691
      config_keys = repository_rugged.config.each_key.to_a
1692 1693 1694 1695 1696
      expect(config_keys).not_to include('test.foo1')
      expect(config_keys).not_to include('test.foo2')
    end
  end

1697 1698 1699 1700 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
  describe '#merge_to_ref' do
    let(:repository) { mutable_repository }
    let(:branch_head) { '6d394385cf567f80a8fd85055db1ab4c5295806f' }
    let(:left_sha) { 'cfe32cf61b73a0d5e9f13e774abde7ff789b1660' }
    let(:right_branch) { 'test-master' }
    let(:target_ref) { 'refs/merge-requests/999/merge' }

    before do
      repository.create_branch(right_branch, branch_head) unless repository.branch_exists?(right_branch)
    end

    def merge_to_ref
      repository.merge_to_ref(user, left_sha, right_branch, target_ref, 'Merge message')
    end

    it 'generates a commit in the target_ref' do
      expect(repository.ref_exists?(target_ref)).to be(false)

      commit_sha = merge_to_ref
      ref_head = repository.commit(target_ref)

      expect(commit_sha).to be_present
      expect(repository.ref_exists?(target_ref)).to be(true)
      expect(ref_head.id).to eq(commit_sha)
    end

    it 'does not change the right branch HEAD' do
      expect { merge_to_ref }.not_to change { repository.find_branch(right_branch).target }
    end
  end

1728
  describe '#merge' do
1729
    let(:repository) { mutable_repository }
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
    let(:source_sha) { '913c66a37b4a45b9769037c55c2d238bd0942d2e' }
    let(:target_branch) { 'test-merge-target-branch' }

    before do
      repository.create_branch(target_branch, '6d394385cf567f80a8fd85055db1ab4c5295806f')
    end

    after do
      ensure_seeds
    end

1741 1742 1743 1744
    it 'can perform a merge' do
      merge_commit_id = nil
      result = repository.merge(user, source_sha, target_branch, 'Test merge') do |commit_id|
        merge_commit_id = commit_id
1745
      end
1746

1747 1748 1749 1750
      expect(result.newrev).to eq(merge_commit_id)
      expect(result.repo_created).to eq(false)
      expect(result.branch_created).to eq(false)
    end
1751

1752 1753 1754 1755 1756
    it 'returns nil if there was a concurrent branch update' do
      concurrent_update_id = '33f3729a45c02fc67d00adb1b8bca394b0e761d9'
      result = repository.merge(user, source_sha, target_branch, 'Test merge') do
        # This ref update should make the merge fail
        repository.write_ref(Gitlab::Git::BRANCH_REF_PREFIX + target_branch, concurrent_update_id)
1757
      end
1758

1759 1760
      # This 'nil' signals that the merge was not applied
      expect(result).to be_nil
1761

1762 1763
      # Our concurrent ref update should not have been undone
      expect(repository.find_branch(target_branch).target).to eq(concurrent_update_id)
1764 1765 1766
    end
  end

1767
  describe '#ff_merge' do
1768
    let(:repository) { mutable_repository }
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
    let(:branch_head) { '6d394385cf567f80a8fd85055db1ab4c5295806f' }
    let(:source_sha) { 'cfe32cf61b73a0d5e9f13e774abde7ff789b1660' }
    let(:target_branch) { 'test-ff-target-branch' }

    before do
      repository.create_branch(target_branch, branch_head)
    end

    after do
      ensure_seeds
    end

    subject { repository.ff_merge(user, source_sha, target_branch) }

1783 1784 1785 1786 1787
    shared_examples '#ff_merge' do
      it 'performs a ff_merge' do
        expect(subject.newrev).to eq(source_sha)
        expect(subject.repo_created).to be(false)
        expect(subject.branch_created).to be(false)
1788

1789 1790
        expect(repository.commit(target_branch).id).to eq(source_sha)
      end
1791

1792 1793
      context 'with a non-existing target branch' do
        subject { repository.ff_merge(user, source_sha, 'this-isnt-real') }
1794

1795 1796 1797
        it 'throws an ArgumentError' do
          expect { subject }.to raise_error(ArgumentError)
        end
1798 1799
      end

1800 1801
      context 'with a non-existing source commit' do
        let(:source_sha) { 'f001' }
1802

1803 1804 1805
        it 'throws an ArgumentError' do
          expect { subject }.to raise_error(ArgumentError)
        end
1806 1807
      end

1808 1809 1810 1811 1812 1813 1814 1815 1816 1817
      context 'when the source sha is not a descendant of the branch head' do
        let(:source_sha) { '1a0b36b3cdad1d2ee32457c102a8c0b7056fa863' }

        it "doesn't perform the ff_merge" do
          expect { subject }.to raise_error(Gitlab::Git::CommitError)

          expect(repository.commit(target_branch).id).to eq(branch_head)
        end
      end
    end
1818

1819 1820 1821 1822
    it "calls Gitaly's OperationService" do
      expect_any_instance_of(Gitlab::GitalyClient::OperationService)
        .to receive(:user_ff_branch).with(user, source_sha, target_branch)
        .and_return(nil)
1823

1824
      subject
1825 1826
    end

1827
    it_behaves_like '#ff_merge'
1828 1829
  end

1830
  describe '#delete_all_refs_except' do
1831
    let(:repository) { mutable_repository }
1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853

    before do
      repository.write_ref("refs/delete/a", "0b4bc9a49b562e85de7cc9e834518ea6828729b9")
      repository.write_ref("refs/also-delete/b", "12d65c8dd2b2676fa3ac47d955accc085a37a9c1")
      repository.write_ref("refs/keep/c", "6473c90867124755509e100d0d35ebdc85a0b6ae")
      repository.write_ref("refs/also-keep/d", "0b4bc9a49b562e85de7cc9e834518ea6828729b9")
    end

    after do
      ensure_seeds
    end

    it 'deletes all refs except those with the specified prefixes' do
      repository.delete_all_refs_except(%w(refs/keep refs/also-keep refs/heads))
      expect(repository.ref_exists?("refs/delete/a")).to be(false)
      expect(repository.ref_exists?("refs/also-delete/b")).to be(false)
      expect(repository.ref_exists?("refs/keep/c")).to be(true)
      expect(repository.ref_exists?("refs/also-keep/d")).to be(true)
      expect(repository.ref_exists?("refs/heads/master")).to be(true)
    end
  end

1854
  describe 'remotes' do
1855
    let(:repository) { mutable_repository }
1856
    let(:remote_name) { 'my-remote' }
1857
    let(:url) { 'http://my-repo.git' }
1858 1859 1860 1861 1862 1863 1864 1865

    after do
      ensure_seeds
    end

    describe '#add_remote' do
      let(:mirror_refmap) { '+refs/*:refs/*' }

1866 1867
      it 'added the remote' do
        begin
1868
          repository_rugged.remotes.delete(remote_name)
1869
        rescue Rugged::ConfigError
1870
        end
1871

1872
        repository.add_remote(remote_name, url, mirror_refmap: mirror_refmap)
1873

1874 1875 1876 1877
        expect(repository_rugged.remotes[remote_name]).not_to be_nil
        expect(repository_rugged.config["remote.#{remote_name}.mirror"]).to eq('true')
        expect(repository_rugged.config["remote.#{remote_name}.prune"]).to eq('true')
        expect(repository_rugged.config["remote.#{remote_name}.fetch"]).to eq(mirror_refmap)
1878 1879 1880 1881
      end
    end

    describe '#remove_remote' do
1882
      it 'removes the remote' do
1883
        repository_rugged.remotes.create(remote_name, url)
1884

1885
        repository.remove_remote(remote_name)
1886

1887
        expect(repository_rugged.remotes[remote_name]).to be_nil
1888 1889 1890 1891
      end
    end
  end

1892
  describe '#bundle_to_disk' do
1893
    let(:save_path) { File.join(Dir.tmpdir, "repo-#{SecureRandom.hex}.bundle") }
1894

1895 1896
    after do
      FileUtils.rm_rf(save_path)
1897 1898
    end

1899 1900
    it 'saves a bundle to disk' do
      repository.bundle_to_disk(save_path)
1901

1902 1903 1904 1905 1906
      success = system(
        *%W(#{Gitlab.config.git.bin_path} -C #{repository_path} bundle verify #{save_path}),
        [:out, :err] => '/dev/null'
      )
      expect(success).to be true
1907 1908 1909
    end
  end

1910
  describe '#create_from_bundle' do
1911 1912
    let(:valid_bundle_path) { File.join(Dir.tmpdir, "repo-#{SecureRandom.hex}.bundle") }
    let(:malicious_bundle_path) { Rails.root.join('spec/fixtures/malicious.bundle') }
1913 1914
    let(:project) { create(:project) }
    let(:imported_repo) { project.repository.raw }
1915

1916
    before do
1917
      expect(repository.bundle_to_disk(valid_bundle_path)).to be_truthy
1918
    end
1919

1920
    after do
1921
      FileUtils.rm_rf(valid_bundle_path)
1922
    end
1923

1924 1925
    it 'creates a repo from a bundle file' do
      expect(imported_repo).not_to exist
1926

1927
      result = imported_repo.create_from_bundle(valid_bundle_path)
1928

1929 1930 1931
      expect(result).to be_truthy
      expect(imported_repo).to exist
      expect { imported_repo.fsck }.not_to raise_exception
1932 1933
    end

1934
    it 'creates a symlink to the global hooks dir' do
1935
      imported_repo.create_from_bundle(valid_bundle_path)
1936
      hooks_path = Gitlab::GitalyClient::StorageSettings.allow_disk_access { File.join(imported_repo.path, 'hooks') }
1937

1938
      expect(File.readlink(hooks_path)).to eq(Gitlab::Shell.new.hooks_path)
1939
    end
1940 1941 1942 1943 1944 1945

    it 'raises an error if the bundle is an attempted malicious payload' do
      expect do
        imported_repo.create_from_bundle(malicious_bundle_path)
      end.to raise_error(::Gitlab::Git::BundleFile::InvalidBundleError)
    end
1946 1947
  end

1948
  describe '#checksum' do
1949
    it 'calculates the checksum for non-empty repo' do
1950
      expect(repository.checksum).to eq '51d0a9662681f93e1fee547a6b7ba2bcaf716059'
1951
    end
1952

1953 1954
    it 'returns 0000000000000000000000000000000000000000 for an empty repo' do
      FileUtils.rm_rf(File.join(storage_path, 'empty-repo.git'))
1955

1956 1957 1958 1959
      system(git_env, *%W(#{Gitlab.config.git.bin_path} init --bare empty-repo.git),
             chdir: storage_path,
             out:   '/dev/null',
             err:   '/dev/null')
1960

1961
      empty_repo = described_class.new('default', 'empty-repo.git', '', 'group/empty-repo')
1962

1963 1964
      expect(empty_repo.checksum).to eq '0000000000000000000000000000000000000000'
    end
1965

1966 1967
    it 'raises Gitlab::Git::Repository::InvalidRepository error for non-valid git repo' do
      FileUtils.rm_rf(File.join(storage_path, 'non-valid.git'))
1968

1969 1970 1971 1972
      system(git_env, *%W(#{Gitlab.config.git.bin_path} clone --bare #{TEST_REPO_PATH} non-valid.git),
             chdir: SEED_STORAGE_PATH,
             out: '/dev/null',
             err: '/dev/null')
1973

1974
      File.truncate(File.join(storage_path, 'non-valid.git/HEAD'), 0)
1975

1976
      non_valid = described_class.new('default', 'non-valid.git', '', 'a/non-valid')
1977

1978
      expect { non_valid.checksum }.to raise_error(Gitlab::Git::Repository::InvalidRepository)
1979 1980
    end

1981
    it 'raises Gitlab::Git::Repository::NoRepository error when there is no repo' do
1982
      broken_repo = described_class.new('default', 'a/path.git', '', 'a/path')
1983

1984
      expect { broken_repo.checksum }.to raise_error(Gitlab::Git::Repository::NoRepository)
1985 1986 1987
    end
  end

1988 1989
  describe '#clean_stale_repository_files' do
    let(:worktree_path) { File.join(repository_path, 'worktrees', 'delete-me') }
1990

1991 1992 1993
    it 'cleans up the files' do
      create_worktree = %W[git -C #{repository_path} worktree add --detach #{worktree_path} master]
      raise 'preparation failed' unless system(*create_worktree, err: '/dev/null')
1994

1995 1996 1997 1998
      FileUtils.touch(worktree_path, mtime: Time.now - 8.hours)
      # git rev-list --all will fail in git 2.16 if HEAD is pointing to a non-existent object,
      # but the HEAD must be 40 characters long or git will ignore it.
      File.write(File.join(worktree_path, 'HEAD'), Gitlab::Git::BLANK_SHA)
1999

2000 2001
      # git 2.16 fails with "fatal: bad object HEAD"
      expect(rev_list_all).to be false
2002

2003
      repository.clean_stale_repository_files
2004

2005 2006
      expect(rev_list_all).to be true
      expect(File.exist?(worktree_path)).to be_falsey
2007 2008
    end

2009 2010
    def rev_list_all
      system(*%W[git -C #{repository_path} rev-list --all], out: '/dev/null', err: '/dev/null')
2011 2012
    end

2013 2014
    it 'increments a counter upon an error' do
      expect(repository.gitaly_repository_client).to receive(:cleanup).and_raise(Gitlab::Git::CommandError)
2015

2016
      counter = double(:counter)
2017

2018 2019 2020
      expect(counter).to receive(:increment)
      expect(Gitlab::Metrics).to receive(:counter).with(:failed_repository_cleanup_total,
                                                        'Number of failed repository cleanup events').and_return(counter)
2021

2022
      repository.clean_stale_repository_files
2023
    end
2024
  end
2025

2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
  describe '#squash' do
    let(:squash_id) { '1' }
    let(:branch_name) { 'fix' }
    let(:start_sha) { '4b4918a572fa86f9771e5ba40fbd48e1eb03e2c6' }
    let(:end_sha) { '12d65c8dd2b2676fa3ac47d955accc085a37a9c1' }

    subject do
      opts = {
        branch: branch_name,
        start_sha: start_sha,
        end_sha: end_sha,
        author: user,
        message: 'Squash commit message'
      }

      repository.squash(user, squash_id, opts)
    end

    # Should be ported to gitaly-ruby rspec suite https://gitlab.com/gitlab-org/gitaly/issues/1234
    skip 'sparse checkout' do
      let(:expected_files) { %w(files files/js files/js/application.js) }

      it 'checks out only the files in the diff' do
        allow(repository).to receive(:with_worktree).and_wrap_original do |m, *args|
          m.call(*args) do
            worktree_path = args[0]
            files_pattern = File.join(worktree_path, '**', '*')
            expected = expected_files.map do |path|
              File.expand_path(path, worktree_path)
            end
2056

2057 2058 2059
            expect(Dir[files_pattern]).to eq(expected)
          end
        end
2060

2061
        subject
2062 2063
      end

2064
      context 'when the diff contains a rename' do
2065
        let(:end_sha) { new_commit_move_file(repository_rugged).oid }
2066 2067 2068

        after do
          # Erase our commits so other tests get the original repo
2069
          repository_rugged.references.update('refs/heads/master', SeedRepo::LastCommit::ID)
2070
        end
2071

2072
        it 'does not include the renamed file in the sparse checkout' do
2073 2074 2075 2076 2077
          allow(repository).to receive(:with_worktree).and_wrap_original do |m, *args|
            m.call(*args) do
              worktree_path = args[0]
              files_pattern = File.join(worktree_path, '**', '*')

2078 2079
              expect(Dir[files_pattern]).not_to include('CHANGELOG')
              expect(Dir[files_pattern]).not_to include('encoding/CHANGELOG')
2080 2081 2082 2083 2084 2085
            end
          end

          subject
        end
      end
2086
    end
2087

2088 2089 2090
    # Should be ported to gitaly-ruby rspec suite https://gitlab.com/gitlab-org/gitaly/issues/1234
    skip 'with an ASCII-8BIT diff' do
      let(:diff) { "diff --git a/README.md b/README.md\nindex faaf198..43c5edf 100644\n--- a/README.md\n+++ b/README.md\n@@ -1,4 +1,4 @@\n-testme\n+✓ testme\n ======\n \n Sample repo for testing gitlab features\n" }
2091

2092 2093 2094
      it 'applies a ASCII-8BIT diff' do
        allow(repository).to receive(:run_git!).and_call_original
        allow(repository).to receive(:run_git!).with(%W(diff --binary #{start_sha}...#{end_sha})).and_return(diff.force_encoding('ASCII-8BIT'))
2095

2096
        expect(subject).to match(/\h{40}/)
2097
      end
2098
    end
2099

2100 2101 2102
    # Should be ported to gitaly-ruby rspec suite https://gitlab.com/gitlab-org/gitaly/issues/1234
    skip 'with trailing whitespace in an invalid patch' do
      let(:diff) { "diff --git a/README.md b/README.md\nindex faaf198..43c5edf 100644\n--- a/README.md\n+++ b/README.md\n@@ -1,4 +1,4 @@\n-testme\n+   \n ======   \n \n Sample repo for testing gitlab features\n" }
2103

2104 2105 2106
      it 'does not include whitespace warnings in the error' do
        allow(repository).to receive(:run_git!).and_call_original
        allow(repository).to receive(:run_git!).with(%W(diff --binary #{start_sha}...#{end_sha})).and_return(diff.force_encoding('ASCII-8BIT'))
2107

2108 2109 2110
        expect { subject }.to raise_error do |error|
          expect(error).to be_a(described_class::GitError)
          expect(error.message).not_to include('trailing whitespace')
2111 2112
        end
      end
2113
    end
2114 2115
  end

2116
  def create_remote_branch(remote_name, branch_name, source_branch_name)
2117
    source_branch = repository.branches.find { |branch| branch.name == source_branch_name }
2118
    repository_rugged.references.create("refs/remotes/#{remote_name}/#{branch_name}", source_branch.dereferenced_target.sha)
Robert Speicher's avatar
Robert Speicher committed
2119 2120 2121
  end

  # Build the options hash that's passed to Rugged::Commit#create
2122
  def commit_options(repo, index, target, ref, message)
Robert Speicher's avatar
Robert Speicher committed
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
    options = {}
    options[:tree] = index.write_tree(repo)
    options[:author] = {
      email: "test@example.com",
      name: "Test Author",
      time: Time.gm(2014, "mar", 3, 20, 15, 1)
    }
    options[:committer] = {
      email: "test@example.com",
      name: "Test Author",
      time: Time.gm(2014, "mar", 3, 20, 15, 1)
    }
    options[:message] ||= message
2136 2137
    options[:parents] = repo.empty? ? [] : [target].compact
    options[:update_ref] = ref
Robert Speicher's avatar
Robert Speicher committed
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152

    options
  end

  # Writes a new commit to the repo and returns a Rugged::Commit.  Replaces the
  # contents of CHANGELOG with a single new line of text.
  def new_commit_edit_old_file(repo)
    oid = repo.write("I replaced the changelog with this text", :blob)
    index = repo.index
    index.read_tree(repo.head.target.tree)
    index.add(path: "CHANGELOG", oid: oid, mode: 0100644)

    options = commit_options(
      repo,
      index,
2153 2154
      repo.head.target,
      "HEAD",
Robert Speicher's avatar
Robert Speicher committed
2155 2156 2157 2158 2159 2160 2161 2162
      "Edit CHANGELOG in its original location"
    )

    sha = Rugged::Commit.create(repo, options)
    repo.lookup(sha)
  end

  # Writes a new commit to the repo and returns a Rugged::Commit.  Replaces the
2163 2164 2165
  # contents of the specified file_path with new text.
  def new_commit_edit_new_file(repo, file_path, commit_message, text, branch = repo.head)
    oid = repo.write(text, :blob)
Robert Speicher's avatar
Robert Speicher committed
2166
    index = repo.index
2167 2168 2169
    index.read_tree(branch.target.tree)
    index.add(path: file_path, oid: oid, mode: 0100644)
    options = commit_options(repo, index, branch.target, branch.canonical_name, commit_message)
Robert Speicher's avatar
Robert Speicher committed
2170 2171 2172 2173
    sha = Rugged::Commit.create(repo, options)
    repo.lookup(sha)
  end

2174 2175 2176 2177 2178 2179 2180
  # Writes a new commit to the repo and returns a Rugged::Commit.  Replaces the
  # contents of encoding/CHANGELOG with new text.
  def new_commit_edit_new_file_on_branch(repo, file_path, branch_name, commit_message, text)
    branch = repo.branches[branch_name]
    new_commit_edit_new_file(repo, file_path, commit_message, text, branch)
  end

Robert Speicher's avatar
Robert Speicher committed
2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191
  # Writes a new commit to the repo and returns a Rugged::Commit.  Moves the
  # CHANGELOG file to the encoding/ directory.
  def new_commit_move_file(repo)
    blob_oid = repo.head.target.tree.detect { |i| i[:name] == "CHANGELOG" }[:oid]
    file_content = repo.lookup(blob_oid).content
    oid = repo.write(file_content, :blob)
    index = repo.index
    index.read_tree(repo.head.target.tree)
    index.add(path: "encoding/CHANGELOG", oid: oid, mode: 0100644)
    index.remove("CHANGELOG")

2192
    options = commit_options(repo, index, repo.head.target, "HEAD", "Move CHANGELOG to encoding/")
Robert Speicher's avatar
Robert Speicher committed
2193 2194 2195 2196

    sha = Rugged::Commit.create(repo, options)
    repo.lookup(sha)
  end
2197 2198 2199 2200 2201 2202

  def refs(dir)
    IO.popen(%W[git -C #{dir} for-each-ref], &:read).split("\n").map do |line|
      line.split("\t").last
    end
  end
Robert Speicher's avatar
Robert Speicher committed
2203
end