BigW Consortium Gitlab

note_spec.rb 21.7 KB
Newer Older
gitlabhq committed
1 2
require 'spec_helper'

Douwe Maan committed
3
describe Note, models: true do
4 5
  include RepoHelpers

6
  describe 'associations' do
7
    it { is_expected.to belong_to(:project) }
8
    it { is_expected.to belong_to(:noteable).touch(true) }
9
    it { is_expected.to belong_to(:author).class_name('User') }
10

11
    it { is_expected.to have_many(:todos).dependent(:destroy) }
gitlabhq committed
12 13
  end

14 15 16 17 18 19 20 21 22 23
  describe 'modules' do
    subject { described_class }

    it { is_expected.to include_module(Participable) }
    it { is_expected.to include_module(Mentionable) }
    it { is_expected.to include_module(Awardable) }

    it { is_expected.to include_module(Gitlab::CurrentSettings) }
  end

24
  describe 'validation' do
25 26
    it { is_expected.to validate_presence_of(:note) }
    it { is_expected.to validate_presence_of(:project) }
27

28
    context 'when note is on commit' do
29 30 31
      before { allow(subject).to receive(:for_commit?).and_return(true) }

      it { is_expected.to validate_presence_of(:commit_id) }
Robert Speicher committed
32
      it { is_expected.not_to validate_presence_of(:noteable_id) }
33 34
    end

35
    context 'when note is not on commit' do
36 37
      before { allow(subject).to receive(:for_commit?).and_return(false) }

Robert Speicher committed
38
      it { is_expected.not_to validate_presence_of(:commit_id) }
39 40 41
      it { is_expected.to validate_presence_of(:noteable_id) }
    end

42
    context 'when noteable and note project differ' do
43
      subject do
44
        build(:note, noteable: build_stubbed(:issue),
45
                     project: build_stubbed(:empty_project))
46 47 48 49 50
      end

      it { is_expected.to be_invalid }
    end

51
    context 'when noteable and note project are the same' do
52 53 54
      subject { create(:note) }
      it { is_expected.to be_valid }
    end
55 56 57 58 59 60 61

    context 'when project is missing for a project related note' do
      subject { build(:note, project: nil, noteable: build_stubbed(:issue)) }
      it { is_expected.to be_invalid }
    end

    context 'when noteable is a personal snippet' do
Jarka Kadlecova committed
62
      subject { build(:note_on_personal_snippet) }
63 64 65 66 67

      it 'is valid without project' do
        is_expected.to be_valid
      end
    end
gitlabhq committed
68 69
  end

70
  describe "Commit notes" do
Riyad Preukschas committed
71 72
    let!(:note) { create(:note_on_commit, note: "+1 from me") }
    let!(:commit) { note.noteable }
73

74
    it "is accessible through #noteable" do
75 76 77
      expect(note.commit_id).to eq(commit.id)
      expect(note.noteable).to be_a(Commit)
      expect(note.noteable).to eq(commit)
78 79
    end

80
    it "saves a valid note" do
81
      expect(note.commit_id).to eq(commit.id)
Riyad Preukschas committed
82
      note.noteable == commit
83 84
    end

85
    it "is recognized by #for_commit?" do
86
      expect(note).to be_for_commit
87
    end
88 89 90 91

    it "keeps the commit around" do
      expect(note.project.repository.kept_around?(commit.id)).to be_truthy
    end
Riyad Preukschas committed
92 93
  end

94
  describe 'authorization' do
Nihad Abbasov committed
95
    before do
96 97
      @p1 = create(:empty_project)
      @p2 = create(:empty_project)
98 99 100
      @u1 = create(:user)
      @u2 = create(:user)
      @u3 = create(:user)
gitlabhq committed
101 102
    end

103
    describe 'read' do
Nihad Abbasov committed
104
      before do
105 106
        @p1.project_members.create(user: @u2, access_level: ProjectMember::GUEST)
        @p2.project_members.create(user: @u3, access_level: ProjectMember::GUEST)
gitlabhq committed
107 108
      end

109 110 111
      it { expect(Ability.allowed?(@u1, :read_note, @p1)).to be_falsey }
      it { expect(Ability.allowed?(@u2, :read_note, @p1)).to be_truthy }
      it { expect(Ability.allowed?(@u3, :read_note, @p1)).to be_falsey }
gitlabhq committed
112 113
    end

114
    describe 'write' do
Nihad Abbasov committed
115
      before do
116 117
        @p1.project_members.create(user: @u2, access_level: ProjectMember::DEVELOPER)
        @p2.project_members.create(user: @u3, access_level: ProjectMember::DEVELOPER)
gitlabhq committed
118 119
      end

120 121 122
      it { expect(Ability.allowed?(@u1, :create_note, @p1)).to be_falsey }
      it { expect(Ability.allowed?(@u2, :create_note, @p1)).to be_truthy }
      it { expect(Ability.allowed?(@u3, :create_note, @p1)).to be_falsey }
gitlabhq committed
123 124
    end

125
    describe 'admin' do
Nihad Abbasov committed
126
      before do
127 128 129
        @p1.project_members.create(user: @u1, access_level: ProjectMember::REPORTER)
        @p1.project_members.create(user: @u2, access_level: ProjectMember::MASTER)
        @p2.project_members.create(user: @u3, access_level: ProjectMember::MASTER)
gitlabhq committed
130 131
      end

132 133 134
      it { expect(Ability.allowed?(@u1, :admin_note, @p1)).to be_falsey }
      it { expect(Ability.allowed?(@u2, :admin_note, @p1)).to be_truthy }
      it { expect(Ability.allowed?(@u3, :admin_note, @p1)).to be_falsey }
gitlabhq committed
135 136
    end
  end
137 138

  it_behaves_like 'an editable mentionable' do
Douwe Maan committed
139
    subject { create :note, noteable: issue, project: issue.project }
140

141
    let(:issue) { create(:issue, project: create(:project, :repository)) }
142 143 144
    let(:backref_text) { issue.gfm_reference }
    let(:set_mentionable_text) { ->(txt) { subject.note = txt } }
  end
145

Douwe Maan committed
146
  describe "#all_references" do
147 148
    let!(:note1) { create(:note_on_issue) }
    let!(:note2) { create(:note_on_issue) }
Douwe Maan committed
149 150

    it "reads the rendered note body from the cache" do
151 152 153 154
      expect(Banzai::Renderer).to receive(:cache_collection_render).
        with([{
          text: note1.note,
          context: {
155
            skip_project_check: false,
156 157 158 159 160 161 162 163 164 165 166
            pipeline: :note,
            cache_key: [note1, "note"],
            project: note1.project,
            author: note1.author
          }
        }]).and_call_original

      expect(Banzai::Renderer).to receive(:cache_collection_render).
        with([{
          text: note2.note,
          context: {
167
            skip_project_check: false,
168 169 170 171 172 173 174 175 176
            pipeline: :note,
            cache_key: [note2, "note"],
            project: note2.project,
            author: note2.author
          }
        }]).and_call_original

      note1.all_references.users
      note2.all_references.users
Douwe Maan committed
177 178 179
    end
  end

180 181 182 183 184 185 186 187 188 189 190
  describe "editable?" do
    it "returns true" do
      note = build(:note)
      expect(note.editable?).to be_truthy
    end

    it "returns false" do
      note = build(:note, system: true)
      expect(note.editable?).to be_falsy
    end
  end
Douwe Maan committed
191

192 193
  describe "cross_reference_not_visible_for?" do
    let(:private_user)    { create(:user) }
194
    let(:private_project) { create(:empty_project, namespace: private_user.namespace) { |p| p.team << [private_user, :master] } }
195 196
    let(:private_issue)   { create(:issue, project: private_project) }

197
    let(:ext_proj)  { create(:empty_project, :public) }
198 199
    let(:ext_issue) { create(:issue, project: ext_proj) }

200
    let(:note) do
201 202
      create :note,
        noteable: ext_issue, project: ext_proj,
203
        note: "mentioned in issue #{private_issue.to_reference(ext_proj)}",
204
        system: true
205
    end
206 207 208 209 210 211 212 213

    it "returns true" do
      expect(note.cross_reference_not_visible_for?(ext_issue.author)).to be_truthy
    end

    it "returns false" do
      expect(note.cross_reference_not_visible_for?(private_user)).to be_falsy
    end
214 215 216 217 218 219 220 221 222 223 224 225 226 227

    it "returns false if user visible reference count set" do
      note.user_visible_reference_count = 1

      expect(note).not_to receive(:reference_mentionables)
      expect(note.cross_reference_not_visible_for?(ext_issue.author)).to be_falsy
    end

    it "returns true if ref count is 0" do
      note.user_visible_reference_count = 0

      expect(note).not_to receive(:reference_mentionables)
      expect(note.cross_reference_not_visible_for?(ext_issue.author)).to be_truthy
    end
228 229
  end

230 231 232 233 234 235 236
  describe 'clear_blank_line_code!' do
    it 'clears a blank line code before validation' do
      note = build(:note, line_code: ' ')

      expect { note.valid? }.to change(note, :line_code).to(nil)
    end
  end
Yorick Peterse committed
237 238 239

  describe '#participants' do
    it 'includes the note author' do
240
      project = create(:empty_project, :public)
Yorick Peterse committed
241 242 243 244 245 246
      issue = create(:issue, project: project)
      note = create(:note_on_issue, noteable: issue, project: project)

      expect(note.participants).to include(note.author)
    end
  end
247

248
  describe '.find_discussion' do
Douwe Maan committed
249 250 251 252
    let!(:note) { create(:discussion_note_on_merge_request) }
    let!(:note2) { create(:discussion_note_on_merge_request, in_reply_to: note) }
    let(:merge_request) { note.noteable }

Douwe Maan committed
253
    it 'returns a discussion with multiple notes' do
Douwe Maan committed
254 255 256 257 258 259
      discussion = merge_request.notes.find_discussion(note.discussion_id)

      expect(discussion).not_to be_nil
      expect(discussion.notes).to match_array([note, note2])
      expect(discussion.first_note.discussion_id).to eq(note.discussion_id)
    end
260 261
  end

262 263 264 265
  describe ".grouped_diff_discussions" do
    let!(:merge_request) { create(:merge_request) }
    let(:project) { merge_request.project }
    let!(:active_diff_note1) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
Douwe Maan committed
266
    let!(:active_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, in_reply_to: active_diff_note1) }
267 268
    let!(:active_diff_note3) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: active_position2) }
    let!(:outdated_diff_note1) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: outdated_position) }
Douwe Maan committed
269
    let!(:outdated_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, in_reply_to: outdated_diff_note1) }
270 271 272 273 274

    let(:active_position2) do
      Gitlab::Diff::Position.new(
        old_path: "files/ruby/popen.rb",
        new_path: "files/ruby/popen.rb",
275 276 277
        old_line: nil,
        new_line: 13,
        diff_refs: project.commit(sample_commit.id).diff_refs
278 279 280 281 282 283 284 285 286 287 288 289 290
      )
    end

    let(:outdated_position) do
      Gitlab::Diff::Position.new(
        old_path: "files/ruby/popen.rb",
        new_path: "files/ruby/popen.rb",
        old_line: nil,
        new_line: 9,
        diff_refs: project.commit("874797c3a73b60d2187ed6e2fcabd289ff75171e").diff_refs
      )
    end

291 292
    context 'active diff discussions' do
      subject { merge_request.notes.grouped_diff_discussions }
293

294 295
      it "includes active discussions" do
        discussions = subject.values.flatten
296

297 298 299
        expect(discussions.count).to eq(2)
        expect(discussions.map(&:id)).to eq([active_diff_note1.discussion_id, active_diff_note3.discussion_id])
        expect(discussions.all?(&:active?)).to be true
300

301 302 303
        expect(discussions.first.notes).to eq([active_diff_note1, active_diff_note2])
        expect(discussions.last.notes).to eq([active_diff_note3])
      end
304

305 306 307 308 309 310 311 312
      it "doesn't include outdated discussions" do
        expect(subject.values.flatten.map(&:id)).not_to include(outdated_diff_note1.discussion_id)
      end

      it "groups the discussions by line code" do
        expect(subject[active_diff_note1.line_code].first.id).to eq(active_diff_note1.discussion_id)
        expect(subject[active_diff_note3.line_code].first.id).to eq(active_diff_note3.discussion_id)
      end
313 314
    end

315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
    context 'diff discussions for older diff refs' do
      subject { merge_request.notes.grouped_diff_discussions(diff_refs) }

      context 'for diff refs a discussion was created at' do
        let(:diff_refs) { active_position2.diff_refs }

        it "includes discussions that were created then" do
          discussions = subject.values.flatten

          expect(discussions.count).to eq(1)

          discussion = discussions.first

          expect(discussion.id).to eq(active_diff_note3.discussion_id)
          expect(discussion.active?).to be true
          expect(discussion.active?(diff_refs)).to be false
          expect(discussion.created_at_diff?(diff_refs)).to be true

          expect(discussion.notes).to eq([active_diff_note3])
        end

        it "groups the discussions by original line code" do
          expect(subject[active_diff_note3.original_line_code].first.id).to eq(active_diff_note3.discussion_id)
        end
      end

      context 'for diff refs a discussion was last active at' do
        let(:diff_refs) { outdated_position.diff_refs }

        it "includes discussions that were last active" do
          discussions = subject.values.flatten

          expect(discussions.count).to eq(1)

          discussion = discussions.first

          expect(discussion.id).to eq(outdated_diff_note1.discussion_id)
          expect(discussion.active?).to be false
          expect(discussion.active?(diff_refs)).to be true
          expect(discussion.created_at_diff?(diff_refs)).to be true

          expect(discussion.notes).to eq([outdated_diff_note1, outdated_diff_note2])
        end

        it "groups the discussions by line code" do
          expect(subject[outdated_diff_note1.line_code].first.id).to eq(outdated_diff_note1.discussion_id)
        end
      end
363 364
    end
  end
365

Jarka Kadlecova committed
366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 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 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430
  describe '#for_personal_snippet?' do
    it 'returns false for a project snippet note' do
      expect(build(:note_on_project_snippet).for_personal_snippet?).to be_falsy
    end

    it 'returns true for a personal snippet note' do
      expect(build(:note_on_personal_snippet).for_personal_snippet?).to be_truthy
    end
  end

  describe '#to_ability_name' do
    it 'returns snippet for a project snippet note' do
      expect(build(:note_on_project_snippet).to_ability_name).to eq('snippet')
    end

    it 'returns personal_snippet for a personal snippet note' do
      expect(build(:note_on_personal_snippet).to_ability_name).to eq('personal_snippet')
    end

    it 'returns merge_request for an MR note' do
      expect(build(:note_on_merge_request).to_ability_name).to eq('merge_request')
    end

    it 'returns issue for an issue note' do
      expect(build(:note_on_issue).to_ability_name).to eq('issue')
    end

    it 'returns issue for a commit note' do
      expect(build(:note_on_commit).to_ability_name).to eq('commit')
    end
  end

  describe '#cache_markdown_field' do
    let(:html) { '<p>some html</p>'}

    context 'note for a project snippet' do
      let(:note) { build(:note_on_project_snippet) }

      before do
        expect(Banzai::Renderer).to receive(:cacheless_render_field).
          with(note, :note, { skip_project_check: false }).and_return(html)

        note.save
      end

      it 'creates a note' do
        expect(note.note_html).to eq(html)
      end
    end

    context 'note for a personal snippet' do
      let(:note) { build(:note_on_personal_snippet) }

      before do
        expect(Banzai::Renderer).to receive(:cacheless_render_field).
          with(note, :note, { skip_project_check: true }).and_return(html)

        note.save
      end

      it 'creates a note' do
        expect(note.note_html).to eq(html)
      end
    end
  end
431

432
  describe '#can_be_discussion_note?' do
Douwe Maan committed
433 434
    context 'for a note on a merge request' do
      it 'returns true' do
Douwe Maan committed
435 436
        note = build(:note_on_merge_request)

Douwe Maan committed
437 438 439 440 441 442
        expect(note.can_be_discussion_note?).to be_truthy
      end
    end

    context 'for a note on an issue' do
      it 'returns true' do
Douwe Maan committed
443 444
        note = build(:note_on_issue)

Douwe Maan committed
445 446 447 448 449 450
        expect(note.can_be_discussion_note?).to be_truthy
      end
    end

    context 'for a note on a commit' do
      it 'returns true' do
Douwe Maan committed
451 452
        note = build(:note_on_commit)

Douwe Maan committed
453 454 455 456 457 458
        expect(note.can_be_discussion_note?).to be_truthy
      end
    end

    context 'for a note on a snippet' do
      it 'returns true' do
Douwe Maan committed
459 460
        note = build(:note_on_project_snippet)

Douwe Maan committed
461 462 463 464 465 466
        expect(note.can_be_discussion_note?).to be_truthy
      end
    end

    context 'for a diff note on merge request' do
      it 'returns false' do
Douwe Maan committed
467 468
        note = build(:diff_note_on_merge_request)

Douwe Maan committed
469 470 471 472 473 474
        expect(note.can_be_discussion_note?).to be_falsey
      end
    end

    context 'for a diff note on commit' do
      it 'returns false' do
Douwe Maan committed
475 476
        note = build(:diff_note_on_commit)

Douwe Maan committed
477 478 479 480 481 482
        expect(note.can_be_discussion_note?).to be_falsey
      end
    end

    context 'for a discussion note' do
      it 'returns false' do
Douwe Maan committed
483 484
        note = build(:discussion_note_on_merge_request)

Douwe Maan committed
485 486 487
        expect(note.can_be_discussion_note?).to be_falsey
      end
    end
488 489 490
  end

  describe '#discussion_class' do
Douwe Maan committed
491 492 493 494 495 496 497 498 499 500 501 502 503 504
    let(:note) { build(:note_on_commit) }
    let(:merge_request) { create(:merge_request) }

    context 'when the note is displayed out of context' do
      it 'returns OutOfContextDiscussion' do
        expect(note.discussion_class(merge_request)).to be(OutOfContextDiscussion)
      end
    end

    context 'when the note is displayed in the original context' do
      it 'returns IndividualNoteDiscussion' do
        expect(note.discussion_class(note.noteable)).to be(IndividualNoteDiscussion)
      end
    end
505 506 507
  end

  describe "#discussion_id" do
Douwe Maan committed
508
    let(:note) { create(:note_on_commit) }
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529

    context "when it is newly created" do
      it "has a discussion id" do
        expect(note.discussion_id).not_to be_nil
        expect(note.discussion_id).to match(/\A\h{40}\z/)
      end
    end

    context "when it didn't store a discussion id before" do
      before do
        note.update_column(:discussion_id, nil)
      end

      it "has a discussion id" do
        # The discussion_id is set in `after_initialize`, so `reload` won't work
        reloaded_note = Note.find(note.id)

        expect(reloaded_note.discussion_id).not_to be_nil
        expect(reloaded_note.discussion_id).to match(/\A\h{40}\z/)
      end
    end
Douwe Maan committed
530 531 532 533 534 535 536 537

    context 'when the note is displayed out of context' do
      let(:merge_request) { create(:merge_request) }

      it 'overrides the discussion id' do
        expect(note.discussion_id(merge_request)).not_to eq(note.discussion_id)
      end
    end
538 539 540 541
  end

  describe '#to_discussion' do
    subject { create(:discussion_note_on_merge_request) }
Douwe Maan committed
542
    let!(:note2) { create(:discussion_note_on_merge_request, project: subject.project, noteable: subject.noteable, in_reply_to: subject) }
543 544 545 546 547 548 549 550 551 552 553 554 555 556

    it "returns a discussion with just this note" do
      discussion = subject.to_discussion

      expect(discussion.id).to eq(subject.discussion_id)
      expect(discussion.notes).to eq([subject])
    end
  end

  describe "#discussion" do
    let!(:note1) { create(:discussion_note_on_merge_request) }
    let!(:note2) { create(:diff_note_on_merge_request, project: note1.project, noteable: note1.noteable) }

    context 'when the note is part of a discussion' do
Douwe Maan committed
557
      subject { create(:discussion_note_on_merge_request, project: note1.project, noteable: note1.noteable, in_reply_to: note1) }
558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579

      it "returns the discussion this note is in" do
        discussion = subject.discussion

        expect(discussion.id).to eq(subject.discussion_id)
        expect(discussion.notes).to eq([note1, subject])
      end
    end

    context 'when the note is not part of a discussion' do
      subject { create(:note) }

      it "returns a discussion with just this note" do
        discussion = subject.discussion

        expect(discussion.id).to eq(subject.discussion_id)
        expect(discussion.notes).to eq([subject])
      end
    end
  end

  describe "#part_of_discussion?" do
Douwe Maan committed
580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 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 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
    context 'for a regular note' do
      let(:note) { build(:note) }

      it 'returns false' do
        expect(note.part_of_discussion?).to be_falsey
      end
    end

    context 'for a diff note' do
      let(:note) { build(:diff_note_on_commit) }

      it 'returns true' do
        expect(note.part_of_discussion?).to be_truthy
      end
    end

    context 'for a discussion note' do
      let(:note) { build(:discussion_note_on_merge_request) }

      it 'returns true' do
        expect(note.part_of_discussion?).to be_truthy
      end
    end
  end

  describe '#in_reply_to?' do
    context 'for a note' do
      context 'when part of a discussion' do
        subject { create(:discussion_note_on_issue) }
        let(:note) { create(:discussion_note_on_issue, in_reply_to: subject) }

        it 'checks if the note is in reply to the other discussion' do
          expect(subject).to receive(:in_reply_to?).with(note).and_call_original
          expect(subject).to receive(:in_reply_to?).with(note.noteable).and_call_original
          expect(subject).to receive(:in_reply_to?).with(note.to_discussion).and_call_original

          subject.in_reply_to?(note)
        end
      end

      context 'when not part of a discussion' do
        subject { create(:note) }
        let(:note) { create(:note, in_reply_to: subject) }

        it 'checks if the note is in reply to the other noteable' do
          expect(subject).to receive(:in_reply_to?).with(note).and_call_original
          expect(subject).to receive(:in_reply_to?).with(note.noteable).and_call_original

          subject.in_reply_to?(note)
        end
      end
    end

    context 'for a discussion' do
      context 'when part of the same discussion' do
        subject { create(:diff_note_on_merge_request) }
        let(:note) { create(:diff_note_on_merge_request, in_reply_to: subject) }

        it 'returns true' do
          expect(subject.in_reply_to?(note.to_discussion)).to be_truthy
        end
      end

      context 'when not part of the same discussion' do
        subject { create(:diff_note_on_merge_request) }
        let(:note) { create(:diff_note_on_merge_request) }

        it 'returns false' do
          expect(subject.in_reply_to?(note.to_discussion)).to be_falsey
        end
      end
    end

    context 'for a noteable' do
      context 'when a comment on the same noteable' do
        subject { create(:note) }
        let(:note) { create(:note, in_reply_to: subject) }

        it 'returns true' do
          expect(subject.in_reply_to?(note.noteable)).to be_truthy
        end
      end

      context 'when not a comment on the same noteable' do
        subject { create(:note) }
        let(:note) { create(:note) }

        it 'returns false' do
          expect(subject.in_reply_to?(note.noteable)).to be_falsey
        end
      end
    end
672 673
  end

674 675 676
  describe 'expiring ETag cache' do
    let(:note) { build(:note_on_issue) }

677
    def expect_expiration(note)
678 679 680
      expect_any_instance_of(Gitlab::EtagCaching::Store)
        .to receive(:touch)
        .with("/#{note.project.namespace.to_param}/#{note.project.to_param}/noteable/issue/#{note.noteable.id}/notes")
681 682 683 684
    end

    it "expires cache for note's issue when note is saved" do
      expect_expiration(note)
685 686 687

      note.save!
    end
688 689 690 691 692 693

    it "expires cache for note's issue when note is destroyed" do
      expect_expiration(note)

      note.destroy!
    end
694
  end
gitlabhq committed
695
end