BigW Consortium Gitlab

commits_spec.rb 24 KB
Newer Older
1 2 3
require 'spec_helper'
require 'mime/types'

4
describe API::Commits, api: true  do
5 6 7
  include ApiHelpers
  let(:user) { create(:user) }
  let(:user2) { create(:user) }
8
  let!(:project) { create(:project, :repository, creator: user, namespace: user.namespace) }
9 10
  let!(:master) { create(:project_member, :master, user: user, project: project) }
  let!(:guest) { create(:project_member, :guest, user: user2, project: project) }
11
  let!(:note) { create(:note_on_commit, author: user, project: project, commit_id: project.repository.commit.id, note: 'a comment on a commit') }
12
  let!(:another_note) { create(:note_on_commit, author: user, project: project, commit_id: project.repository.commit.id, note: 'another comment on a commit') }
13 14 15

  before { project.team << [user, :reporter] }

Marc Siegfriedt committed
16
  describe "List repository commits" do
17 18 19
    context "authorized user" do
      before { project.team << [user2, :reporter] }

20
      it "returns project commits" do
21
        commit = project.repository.commit
22

23 24
        get api("/projects/#{project.id}/repository/commits", user)

25
        expect(response).to have_http_status(200)
26
        expect(json_response).to be_an Array
27 28 29
        expect(json_response.first['id']).to eq(commit.id)
        expect(json_response.first['committer_name']).to eq(commit.committer_name)
        expect(json_response.first['committer_email']).to eq(commit.committer_email)
30
      end
31 32 33 34 35 36 37 38 39 40

      it 'include correct pagination headers' do
        commit_count = project.repository.count_commits(ref: 'master').to_s

        get api("/projects/#{project.id}/repository/commits", user)

        expect(response).to include_pagination_headers
        expect(response.headers['X-Total']).to eq(commit_count)
        expect(response.headers['X-Page']).to eql('1')
      end
41 42 43
    end

    context "unauthorized user" do
44
      it "does not return project commits" do
45
        get api("/projects/#{project.id}/repository/commits")
46
        expect(response).to have_http_status(401)
47 48
      end
    end
49 50

    context "since optional parameter" do
51
      it "returns project commits since provided parameter" do
52
        commits = project.repository.commits("master")
53
        after = commits.second.created_at
54

55
        get api("/projects/#{project.id}/repository/commits?since=#{after.utc.iso8601}", user)
56 57 58 59 60

        expect(json_response.size).to eq 2
        expect(json_response.first["id"]).to eq(commits.first.id)
        expect(json_response.second["id"]).to eq(commits.second.id)
      end
61 62 63 64 65 66 67 68 69 70 71 72

      it 'include correct pagination headers' do
        commits = project.repository.commits("master")
        after = commits.second.created_at
        commit_count = project.repository.count_commits(ref: 'master', after: after).to_s

        get api("/projects/#{project.id}/repository/commits?since=#{after.utc.iso8601}", user)

        expect(response).to include_pagination_headers
        expect(response.headers['X-Total']).to eq(commit_count)
        expect(response.headers['X-Page']).to eql('1')
      end
73 74 75
    end

    context "until optional parameter" do
76
      it "returns project commits until provided parameter" do
77 78 79 80 81
        commits = project.repository.commits("master")
        before = commits.second.created_at

        get api("/projects/#{project.id}/repository/commits?until=#{before.utc.iso8601}", user)

82 83 84 85 86 87
        if commits.size >= 20
          expect(json_response.size).to eq(20)
        else
          expect(json_response.size).to eq(commits.size - 1)
        end

88 89 90
        expect(json_response.first["id"]).to eq(commits.second.id)
        expect(json_response.second["id"]).to eq(commits.third.id)
      end
91 92 93 94 95 96 97 98 99 100 101 102

      it 'include correct pagination headers' do
        commits = project.repository.commits("master")
        before = commits.second.created_at
        commit_count = project.repository.count_commits(ref: 'master', before: before).to_s

        get api("/projects/#{project.id}/repository/commits?until=#{before.utc.iso8601}", user)

        expect(response).to include_pagination_headers
        expect(response.headers['X-Total']).to eq(commit_count)
        expect(response.headers['X-Page']).to eql('1')
      end
103 104 105
    end

    context "invalid xmlschema date parameters" do
106
      it "returns an invalid parameter error message" do
107 108
        get api("/projects/#{project.id}/repository/commits?since=invalid-date", user)

109
        expect(response).to have_http_status(400)
110
        expect(json_response['error']).to eq('since is invalid')
111 112
      end
    end
113 114 115 116

    context "path optional parameter" do
      it "returns project commits matching provided path parameter" do
        path = 'files/ruby/popen.rb'
117
        commit_count = project.repository.count_commits(ref: 'master', path: path).to_s
118 119 120 121 122

        get api("/projects/#{project.id}/repository/commits?path=#{path}", user)

        expect(json_response.size).to eq(3)
        expect(json_response.first["id"]).to eq("570e7b2abdd848b95f2f578043fc23bd6f6fd24d")
123 124
        expect(response).to include_pagination_headers
        expect(response.headers['X-Total']).to eq(commit_count)
125
      end
126

127 128 129 130 131 132 133 134 135 136 137
      it 'include correct pagination headers' do
        path = 'files/ruby/popen.rb'
        commit_count = project.repository.count_commits(ref: 'master', path: path).to_s

        get api("/projects/#{project.id}/repository/commits?path=#{path}", user)

        expect(response).to include_pagination_headers
        expect(response.headers['X-Total']).to eq(commit_count)
        expect(response.headers['X-Page']).to eql('1')
      end
    end
138

139 140
    context 'with pagination params' do
      let(:page) { 1 }
141 142 143 144 145 146
      let(:per_page) { 5 }
      let(:ref_name) { 'master' }
      let!(:request) do
        get api("/projects/#{project.id}/repository/commits?page=#{page}&per_page=#{per_page}&ref_name=#{ref_name}", user)
      end

147 148
      it 'returns correct headers' do
        commit_count = project.repository.count_commits(ref: ref_name).to_s
149

150
        expect(response).to include_pagination_headers
151
        expect(response.headers['X-Total']).to eq(commit_count)
152 153 154
        expect(response.headers['X-Page']).to eq('1')
        expect(response.headers['Link']).to match(/page=1&per_page=5/)
        expect(response.headers['Link']).to match(/page=2&per_page=5/)
155 156 157 158 159 160 161 162
      end

      context 'viewing the first page' do
        it 'returns the first 5 commits' do
          commit = project.repository.commit

          expect(json_response.size).to eq(per_page)
          expect(json_response.first['id']).to eq(commit.id)
163
          expect(response.headers['X-Page']).to eq('1')
164 165 166
        end
      end

167 168
      context 'viewing the third page' do
        let(:page) { 3 }
169

170 171
        it 'returns the third 5 commits' do
          commit = project.repository.commits('HEAD', offset: (page - 1) * per_page).first
172 173 174

          expect(json_response.size).to eq(per_page)
          expect(json_response.first['id']).to eq(commit.id)
175
          expect(response.headers['X-Page']).to eq('3')
176 177 178
        end
      end
    end
179 180
  end

181
  describe "POST /projects/:id/repository/commits" do
Marc Siegfriedt committed
182 183 184 185 186 187 188 189 190 191 192 193 194 195
    let!(:url) { "/projects/#{project.id}/repository/commits" }

    it 'returns a 403 unauthorized for user without permissions' do
      post api(url, user2)

      expect(response).to have_http_status(403)
    end

    it 'returns a 400 bad request if no params are given' do
      post api(url, user)

      expect(response).to have_http_status(400)
    end

196
    describe 'create' do
Marc Siegfriedt committed
197 198 199
      let(:message) { 'Created file' }
      let!(:invalid_c_params) do
        {
200
          branch: 'master',
Marc Siegfriedt committed
201 202 203 204 205 206 207 208 209 210 211 212
          commit_message: message,
          actions: [
            {
              action: 'create',
              file_path: 'files/ruby/popen.rb',
              content: 'puts 8'
            }
          ]
        }
      end
      let!(:valid_c_params) do
        {
213
          branch: 'master',
Marc Siegfriedt committed
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
          commit_message: message,
          actions: [
            {
              action: 'create',
              file_path: 'foo/bar/baz.txt',
              content: 'puts 8'
            }
          ]
        }
      end

      it 'a new file in project repo' do
        post api(url, user), valid_c_params

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(message)
230 231
        expect(json_response['committer_name']).to eq(user.name)
        expect(json_response['committer_email']).to eq(user.email)
Marc Siegfriedt committed
232 233 234 235 236 237 238
      end

      it 'returns a 400 bad request if file exists' do
        post api(url, user), invalid_c_params

        expect(response).to have_http_status(400)
      end
239

240 241
      context 'with project path containing a dot in URL' do
        let(:url) { "/projects/#{CGI.escape(project.full_path)}/repository/commits" }
242 243 244 245 246 247 248

        it 'a new file in project repo' do
          post api(url, user), valid_c_params

          expect(response).to have_http_status(201)
        end
      end
Marc Siegfriedt committed
249 250
    end

251
    describe 'delete' do
Marc Siegfriedt committed
252 253 254
      let(:message) { 'Deleted file' }
      let!(:invalid_d_params) do
        {
255
          branch: 'markdown',
Marc Siegfriedt committed
256 257 258 259 260 261 262 263 264 265 266
          commit_message: message,
          actions: [
            {
              action: 'delete',
              file_path: 'doc/api/projects.md'
            }
          ]
        }
      end
      let!(:valid_d_params) do
        {
267
          branch: 'markdown',
Marc Siegfriedt committed
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
          commit_message: message,
          actions: [
            {
              action: 'delete',
              file_path: 'doc/api/users.md'
            }
          ]
        }
      end

      it 'an existing file in project repo' do
        post api(url, user), valid_d_params

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(message)
      end

      it 'returns a 400 bad request if file does not exist' do
        post api(url, user), invalid_d_params

        expect(response).to have_http_status(400)
      end
    end

292
    describe 'move' do
Marc Siegfriedt committed
293 294 295
      let(:message) { 'Moved file' }
      let!(:invalid_m_params) do
        {
296
          branch: 'feature',
Marc Siegfriedt committed
297 298 299 300 301 302 303 304 305 306 307 308 309
          commit_message: message,
          actions: [
            {
              action: 'move',
              file_path: 'CHANGELOG',
              previous_path: 'VERSION',
              content: '6.7.0.pre'
            }
          ]
        }
      end
      let!(:valid_m_params) do
        {
310
          branch: 'feature',
Marc Siegfriedt committed
311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
          commit_message: message,
          actions: [
            {
              action: 'move',
              file_path: 'VERSION.txt',
              previous_path: 'VERSION',
              content: '6.7.0.pre'
            }
          ]
        }
      end

      it 'an existing file in project repo' do
        post api(url, user), valid_m_params

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(message)
      end

      it 'returns a 400 bad request if file does not exist' do
        post api(url, user), invalid_m_params

        expect(response).to have_http_status(400)
      end
    end

337
    describe 'update' do
Marc Siegfriedt committed
338 339 340
      let(:message) { 'Updated file' }
      let!(:invalid_u_params) do
        {
341
          branch: 'master',
Marc Siegfriedt committed
342 343 344 345 346 347 348 349 350 351 352 353
          commit_message: message,
          actions: [
            {
              action: 'update',
              file_path: 'foo/bar.baz',
              content: 'puts 8'
            }
          ]
        }
      end
      let!(:valid_u_params) do
        {
354
          branch: 'master',
Marc Siegfriedt committed
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
          commit_message: message,
          actions: [
            {
              action: 'update',
              file_path: 'files/ruby/popen.rb',
              content: 'puts 8'
            }
          ]
        }
      end

      it 'an existing file in project repo' do
        post api(url, user), valid_u_params

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(message)
      end

      it 'returns a 400 bad request if file does not exist' do
        post api(url, user), invalid_u_params

        expect(response).to have_http_status(400)
      end
    end

380
    describe 'multiple operations' do
Marc Siegfriedt committed
381 382 383
      let(:message) { 'Multiple actions' }
      let!(:invalid_mo_params) do
        {
384
          branch: 'master',
Marc Siegfriedt committed
385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
          commit_message: message,
          actions: [
            {
              action: 'create',
              file_path: 'files/ruby/popen.rb',
              content: 'puts 8'
            },
            {
              action: 'delete',
              file_path: 'doc/api/projects.md'
            },
            {
              action: 'move',
              file_path: 'CHANGELOG',
              previous_path: 'VERSION',
              content: '6.7.0.pre'
            },
            {
              action: 'update',
              file_path: 'foo/bar.baz',
              content: 'puts 8'
            }
          ]
        }
      end
      let!(:valid_mo_params) do
        {
412
          branch: 'master',
Marc Siegfriedt committed
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
          commit_message: message,
          actions: [
            {
              action: 'create',
              file_path: 'foo/bar/baz.txt',
              content: 'puts 8'
            },
            {
              action: 'delete',
              file_path: 'Gemfile.zip'
            },
            {
              action: 'move',
              file_path: 'VERSION.txt',
              previous_path: 'VERSION',
              content: '6.7.0.pre'
            },
            {
              action: 'update',
              file_path: 'files/ruby/popen.rb',
              content: 'puts 8'
            }
          ]
        }
      end

      it 'are commited as one in project repo' do
        post api(url, user), valid_mo_params

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(message)
      end

      it 'return a 400 bad request if there are any issues' do
        post api(url, user), invalid_mo_params

        expect(response).to have_http_status(400)
      end
    end
  end

  describe "Get a single commit" do
455
    context "authorized user" do
456
      it "returns a commit by sha" do
457
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}", user)
458

459
        expect(response).to have_http_status(200)
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474
        commit = project.repository.commit
        expect(json_response['id']).to eq(commit.id)
        expect(json_response['short_id']).to eq(commit.short_id)
        expect(json_response['title']).to eq(commit.title)
        expect(json_response['message']).to eq(commit.safe_message)
        expect(json_response['author_name']).to eq(commit.author_name)
        expect(json_response['author_email']).to eq(commit.author_email)
        expect(json_response['authored_date']).to eq(commit.authored_date.iso8601(3))
        expect(json_response['committer_name']).to eq(commit.committer_name)
        expect(json_response['committer_email']).to eq(commit.committer_email)
        expect(json_response['committed_date']).to eq(commit.committed_date.iso8601(3))
        expect(json_response['parent_ids']).to eq(commit.parent_ids)
        expect(json_response['stats']['additions']).to eq(commit.stats.additions)
        expect(json_response['stats']['deletions']).to eq(commit.stats.deletions)
        expect(json_response['stats']['total']).to eq(commit.stats.total)
475 476
      end

477
      it "returns a 404 error if not found" do
478
        get api("/projects/#{project.id}/repository/commits/invalid_sha", user)
479
        expect(response).to have_http_status(404)
480
      end
481

482
      it "returns nil for commit without CI" do
483
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}", user)
484

485
        expect(response).to have_http_status(200)
Kamil Trzcinski committed
486
        expect(json_response['status']).to be_nil
487 488
      end

489
      it "returns status for CI" do
490
        pipeline = project.ensure_pipeline('master', project.repository.commit.sha)
491 492
        pipeline.update(status: 'success')

493
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}", user)
494

495
        expect(response).to have_http_status(200)
496
        expect(json_response['status']).to eq(pipeline.status)
497
      end
498 499

      it "returns status for CI when pipeline is created" do
500
        project.ensure_pipeline('master', project.repository.commit.sha)
501 502 503 504

        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}", user)

        expect(response).to have_http_status(200)
505
        expect(json_response['status']).to eq("created")
506
      end
507 508 509
    end

    context "unauthorized user" do
510
      it "does not return the selected commit" do
511
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}")
512
        expect(response).to have_http_status(401)
513 514 515 516
      end
    end
  end

Marc Siegfriedt committed
517
  describe "Get the diff of a commit" do
518 519 520
    context "authorized user" do
      before { project.team << [user2, :reporter] }

521
      it "returns the diff of the selected commit" do
522
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/diff", user)
523
        expect(response).to have_http_status(200)
524

525 526 527
        expect(json_response).to be_an Array
        expect(json_response.length).to be >= 1
        expect(json_response.first.keys).to include "diff"
528 529
      end

530
      it "returns a 404 error if invalid commit" do
531
        get api("/projects/#{project.id}/repository/commits/invalid_sha/diff", user)
532
        expect(response).to have_http_status(404)
533 534 535 536
      end
    end

    context "unauthorized user" do
537
      it "does not return the diff of the selected commit" do
538
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/diff")
539
        expect(response).to have_http_status(401)
540 541 542
      end
    end
  end
543

Marc Siegfriedt committed
544
  describe 'Get the comments of a commit' do
545
    context 'authorized user' do
546
      it 'returns merge_request comments' do
547
        get api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user)
548
        expect(response).to have_http_status(200)
549
        expect(response).to include_pagination_headers
550
        expect(json_response).to be_an Array
551
        expect(json_response.length).to eq(2)
552 553
        expect(json_response.first['note']).to eq('a comment on a commit')
        expect(json_response.first['author']['id']).to eq(user.id)
554 555
      end

556
      it 'returns a 404 error if merge_request_id not found' do
557
        get api("/projects/#{project.id}/repository/commits/1234ab/comments", user)
558
        expect(response).to have_http_status(404)
559 560 561 562
      end
    end

    context 'unauthorized user' do
563
      it 'does not return the diff of the selected commit' do
564
        get api("/projects/#{project.id}/repository/commits/1234ab/comments")
565
        expect(response).to have_http_status(401)
566 567
      end
    end
568 569 570 571 572 573 574 575 576 577 578 579 580 581

    context 'when the commit is present on two projects' do
      let(:forked_project) { create(:project, :repository, creator: user2, namespace: user2.namespace) }
      let!(:forked_project_note) { create(:note_on_commit, author: user2, project: forked_project, commit_id: forked_project.repository.commit.id, note: 'a comment on a commit for fork') }

      it 'returns the comments for the target project' do
        get api("/projects/#{forked_project.id}/repository/commits/#{forked_project.repository.commit.id}/comments", user2)

        expect(response).to have_http_status(200)
        expect(json_response.length).to eq(1)
        expect(json_response.first['note']).to eq('a comment on a commit for fork')
        expect(json_response.first['author']['id']).to eq(user2.id)
      end
    end
582 583
  end

584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
  describe 'POST :id/repository/commits/:sha/cherry_pick' do
    let(:master_pickable_commit)  { project.commit('7d3b0f7cff5f37573aea97cebfd5692ea1689924') }

    context 'authorized user' do
      it 'cherry picks a commit' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user), branch: 'master'

        expect(response).to have_http_status(201)
        expect(json_response['title']).to eq(master_pickable_commit.title)
        expect(json_response['message']).to eq(master_pickable_commit.message)
        expect(json_response['author_name']).to eq(master_pickable_commit.author_name)
        expect(json_response['committer_name']).to eq(user.name)
      end

      it 'returns 400 if commit is already included in the target branch' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user), branch: 'markdown'

        expect(response).to have_http_status(400)
        expect(json_response['message']).to eq('Sorry, we cannot cherry-pick this commit automatically.
603
                     A cherry-pick may have already been performed with this commit, or a more recent commit may have updated some of its content.')
604 605 606 607 608 609
      end

      it 'returns 400 if you are not allowed to push to the target branch' do
        project.team << [user2, :developer]
        protected_branch = create(:protected_branch, project: project, name: 'feature')

Robert Schilling committed
610
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user2), branch: protected_branch.name
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653

        expect(response).to have_http_status(400)
        expect(json_response['message']).to eq('You are not allowed to push into this branch')
      end

      it 'returns 400 for missing parameters' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user)

        expect(response).to have_http_status(400)
        expect(json_response['error']).to eq('branch is missing')
      end

      it 'returns 404 if commit is not found' do
        post api("/projects/#{project.id}/repository/commits/abcd0123/cherry_pick", user), branch: 'master'

        expect(response).to have_http_status(404)
        expect(json_response['message']).to eq('404 Commit Not Found')
      end

      it 'returns 404 if branch is not found' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user), branch: 'foo'

        expect(response).to have_http_status(404)
        expect(json_response['message']).to eq('404 Branch Not Found')
      end

      it 'returns 400 for missing parameters' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick", user)

        expect(response).to have_http_status(400)
        expect(json_response['error']).to eq('branch is missing')
      end
    end

    context 'unauthorized user' do
      it 'does not cherry pick the commit' do
        post api("/projects/#{project.id}/repository/commits/#{master_pickable_commit.id}/cherry_pick"), branch: 'master'

        expect(response).to have_http_status(401)
      end
    end
  end

Marc Siegfriedt committed
654
  describe 'Post comment to commit' do
655
    context 'authorized user' do
656
      it 'returns comment' do
657
        post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user), note: 'My comment'
658
        expect(response).to have_http_status(201)
659 660 661 662
        expect(json_response['note']).to eq('My comment')
        expect(json_response['path']).to be_nil
        expect(json_response['line']).to be_nil
        expect(json_response['line_type']).to be_nil
663 664
      end

665
      it 'returns the inline comment' do
666 667
        post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user), note: 'My comment', path: project.repository.commit.raw_diffs.first.new_path, line: 1, line_type: 'new'

668
        expect(response).to have_http_status(201)
669
        expect(json_response['note']).to eq('My comment')
670
        expect(json_response['path']).to eq(project.repository.commit.raw_diffs.first.new_path)
671
        expect(json_response['line']).to eq(1)
672
        expect(json_response['line_type']).to eq('new')
673 674
      end

675
      it 'returns 400 if note is missing' do
676
        post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments", user)
677
        expect(response).to have_http_status(400)
678 679
      end

680
      it 'returns 404 if note is attached to non existent commit' do
681
        post api("/projects/#{project.id}/repository/commits/1234ab/comments", user), note: 'My comment'
682
        expect(response).to have_http_status(404)
683 684 685 686
      end
    end

    context 'unauthorized user' do
687
      it 'does not return the diff of the selected commit' do
688
        post api("/projects/#{project.id}/repository/commits/#{project.repository.commit.id}/comments")
689
        expect(response).to have_http_status(401)
690 691 692
      end
    end
  end
693
end