issue_spec.rb 22.9 KB
Newer Older
gitlabhq's avatar
gitlabhq committed
1 2
require 'spec_helper'

3
describe Issue do
gitlabhq's avatar
gitlabhq committed
4
  describe "Associations" do
5
    it { is_expected.to belong_to(:milestone) }
6
    it { is_expected.to have_many(:assignees) }
gitlabhq's avatar
gitlabhq committed
7 8
  end

9
  describe 'modules' do
10 11 12
    subject { described_class }

    it { is_expected.to include_module(InternalId) }
13
    it { is_expected.to include_module(Issuable) }
14 15 16
    it { is_expected.to include_module(Referable) }
    it { is_expected.to include_module(Sortable) }
    it { is_expected.to include_module(Taskable) }
17 18
  end

19
  subject { create(:issue) }
20

21 22 23 24 25
  describe "act_as_paranoid" do
    it { is_expected.to have_db_column(:deleted_at) }
    it { is_expected.to have_db_index(:deleted_at) }
  end

26 27 28 29 30 31 32 33 34 35
  describe '#order_by_position_and_priority' do
    let(:project) { create :empty_project }
    let(:p1) { create(:label, title: 'P1', project: project, priority: 1) }
    let(:p2) { create(:label, title: 'P2', project: project, priority: 2) }
    let!(:issue1) { create(:labeled_issue, project: project, labels: [p1]) }
    let!(:issue2) { create(:labeled_issue, project: project, labels: [p2]) }
    let!(:issue3) { create(:issue, project: project, relative_position: 100) }
    let!(:issue4) { create(:issue, project: project, relative_position: 200) }

    it 'returns ordered list' do
36 37
      expect(project.issues.order_by_position_and_priority)
        .to match [issue3, issue4, issue1, issue2]
38 39 40
    end
  end

41 42 43 44 45
  describe '#card_attributes' do
    it 'includes the author name' do
      allow(subject).to receive(:author).and_return(double(name: 'Robert'))
      allow(subject).to receive(:assignees).and_return([])

46 47
      expect(subject.card_attributes)
        .to eq({ 'Author' => 'Robert', 'Assignee' => '' })
48 49 50 51 52 53
    end

    it 'includes the assignee name' do
      allow(subject).to receive(:author).and_return(double(name: 'Robert'))
      allow(subject).to receive(:assignees).and_return([double(name: 'Douwe')])

54 55
      expect(subject.card_attributes)
        .to eq({ 'Author' => 'Robert', 'Assignee' => 'Douwe' })
56 57 58
    end
  end

59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
  describe '#closed_at' do
    after do
      Timecop.return
    end

    let!(:now) { Timecop.freeze(Time.now) }

    it 'sets closed_at to Time.now when issue is closed' do
      issue = create(:issue, state: 'opened')

      issue.close

      expect(issue.closed_at).to eq(now)
    end
  end

75
  describe '#to_reference' do
76 77 78 79
    let(:namespace) { build(:namespace, path: 'sample-namespace') }
    let(:project)   { build(:empty_project, name: 'sample-project', namespace: namespace) }
    let(:issue)     { build(:issue, iid: 1, project: project) }
    let(:group)     { create(:group, name: 'Group', path: 'sample-group') }
80

81 82 83 84
    context 'when nil argument' do
      it 'returns issue id' do
        expect(issue.to_reference).to eq "#1"
      end
85 86
    end

87
    context 'when full is true' do
88
      it 'returns complete path to the issue' do
89 90 91
        expect(issue.to_reference(full: true)).to          eq 'sample-namespace/sample-project#1'
        expect(issue.to_reference(project, full: true)).to eq 'sample-namespace/sample-project#1'
        expect(issue.to_reference(group, full: true)).to   eq 'sample-namespace/sample-project#1'
92
      end
93 94
    end

95 96 97 98 99 100 101 102 103 104 105 106
    context 'when same project argument' do
      it 'returns issue id' do
        expect(issue.to_reference(project)).to eq("#1")
      end
    end

    context 'when cross namespace project argument' do
      let(:another_namespace_project) { create(:empty_project, name: 'another-project') }

      it 'returns complete path to the issue' do
        expect(issue.to_reference(another_namespace_project)).to eq 'sample-namespace/sample-project#1'
      end
107 108
    end

109
    it 'supports a cross-project reference' do
110
      another_project = build(:empty_project, name: 'another-project', namespace: project.namespace)
111
      expect(issue.to_reference(another_project)).to eq "sample-project#1"
112
    end
113

114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
    context 'when same namespace / cross-project argument' do
      let(:another_project) { create(:empty_project, namespace: namespace) }

      it 'returns path to the issue with the project name' do
        expect(issue.to_reference(another_project)).to eq 'sample-project#1'
      end
    end

    context 'when different namespace / cross-project argument' do
      let(:another_namespace) { create(:namespace, path: 'another-namespace') }
      let(:another_project)   { create(:empty_project, path: 'another-project', namespace: another_namespace) }

      it 'returns full path to the issue' do
        expect(issue.to_reference(another_project)).to eq 'sample-namespace/sample-project#1'
      end
    end

    context 'when argument is a namespace' do
      context 'with same project path' do
        it 'returns path to the issue with the project name' do
          expect(issue.to_reference(namespace)).to eq 'sample-project#1'
        end
      end

      context 'with different project path' do
        it 'returns full path to the issue' do
          expect(issue.to_reference(group)).to eq 'sample-namespace/sample-project#1'
        end
      end
143
    end
144 145
  end

146 147 148 149 150 151 152 153
  describe '#assignee_or_author?' do
    let(:user) { create(:user) }
    let(:issue) { create(:issue) }

    it 'returns true for a user that is assigned to an issue' do
      issue.assignees << user

      expect(issue.assignee_or_author?(user)).to be_truthy
154
    end
155 156 157 158 159 160 161 162 163

    it 'returns true for a user that is the author of an issue' do
      issue.update(author: user)

      expect(issue.assignee_or_author?(user)).to be_truthy
    end

    it 'returns false for a user that is not the assignee or author' do
      expect(issue.assignee_or_author?(user)).to be_falsey
164 165
    end
  end
Andrew8xx8's avatar
Andrew8xx8 committed
166

167
  describe '#closed_by_merge_requests' do
168 169 170
    let(:project) { create(:project, :repository) }
    let(:issue) { create(:issue, project: project)}
    let(:closed_issue) { build(:issue, :closed, project: project)}
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193

    let(:mr) do
      opts = {
        title: 'Awesome merge_request',
        description: "Fixes #{issue.to_reference}",
        source_branch: 'feature',
        target_branch: 'master'
      }
      MergeRequests::CreateService.new(project, project.owner, opts).execute
    end

    let(:closed_mr) do
      opts = {
        title: 'Awesome merge_request 2',
        description: "Fixes #{issue.to_reference}",
        source_branch: 'feature',
        target_branch: 'master',
        state: 'closed'
      }
      MergeRequests::CreateService.new(project, project.owner, opts).execute
    end

    it 'returns the merge request to close this issue' do
194
      mr
195

196
      expect(issue.closed_by_merge_requests(mr.author)).to eq([mr])
197 198
    end

199 200 201
    it "returns an empty array when the merge request is closed already" do
      closed_mr

202
      expect(issue.closed_by_merge_requests(closed_mr.author)).to eq([])
203 204
    end

205
    it "returns an empty array when the current issue is closed already" do
206
      expect(closed_issue.closed_by_merge_requests(closed_issue.author)).to eq([])
207 208 209
    end
  end

210 211
  describe '#referenced_merge_requests' do
    it 'returns the referenced merge requests' do
212
      project = create(:empty_project, :public)
213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

      mr1 = create(:merge_request,
                   source_project: project,
                   source_branch:  'master',
                   target_branch:  'feature')

      mr2 = create(:merge_request,
                   source_project: project,
                   source_branch:  'feature',
                   target_branch:  'master')

      issue = create(:issue, description: mr1.to_reference, project: project)

      create(:note_on_issue,
             noteable:   issue,
             note:       mr2.to_reference,
             project_id: project.id)

      expect(issue.referenced_merge_requests).to eq([mr1, mr2])
    end
  end

235 236 237 238 239 240 241 242 243 244
  describe '#can_move?' do
    let(:user) { create(:user) }
    let(:issue) { create(:issue) }
    subject { issue.can_move?(user) }

    context 'user is not a member of project issue belongs to' do
      it { is_expected.to eq false}
    end

    context 'user is reporter in project issue belongs to' do
245
      let(:project) { create(:empty_project) }
246 247
      let(:issue) { create(:issue, project: project) }

248 249 250
      before do
        project.team << [user, :reporter]
      end
251 252 253

      it { is_expected.to eq true }

254 255 256 257 258
      context 'issue not persisted' do
        let(:issue) { build(:issue, project: project) }
        it { is_expected.to eq false }
      end

259 260
      context 'checking destination project also' do
        subject { issue.can_move?(user, to_project) }
261
        let(:to_project) { create(:empty_project) }
262 263

        context 'destination project allowed' do
264 265 266 267
          before do
            to_project.team << [user, :reporter]
          end

268 269 270 271
          it { is_expected.to eq true }
        end

        context 'destination project not allowed' do
272 273 274 275
          before do
            to_project.team << [user, :guest]
          end

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
          it { is_expected.to eq false }
        end
      end
    end
  end

  describe '#moved?' do
    let(:issue) { create(:issue) }
    subject { issue.moved? }

    context 'issue not moved' do
      it { is_expected.to eq false }
    end

    context 'issue already moved' do
      let(:moved_to_issue) { create(:issue) }
      let(:issue) { create(:issue, moved_to: moved_to_issue) }

      it { is_expected.to eq true }
    end
  end

Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
298
  describe '#related_branches' do
299
    let(:user) { build(:admin) }
300

301
    before do
302 303
      allow(subject.project.repository).to receive(:branch_names)
                                            .and_return(["mpempe", "#{subject.iid}mepmep", subject.to_branch_name, "#{subject.iid}-branch"])
304 305 306 307 308 309 310 311

      # Without this stub, the `create(:merge_request)` above fails because it can't find
      # the source branch. This seems like a reasonable compromise, in comparison with
      # setting up a full repo here.
      allow_any_instance_of(MergeRequest).to receive(:create_merge_request_diff)
    end

    it "selects the right branches when there are no referenced merge requests" do
312
      expect(subject.related_branches(user)).to eq([subject.to_branch_name, "#{subject.iid}-branch"])
313
    end
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
314

315
    it "selects the right branches when there is a referenced merge request" do
Timothy Andrew's avatar
Timothy Andrew committed
316 317
      merge_request = create(:merge_request, { description: "Closes ##{subject.iid}",
                                               source_project: subject.project,
318
                                               source_branch: "#{subject.iid}-branch" })
319
      merge_request.create_cross_references!(user)
320
      expect(subject.referenced_merge_requests(user)).not_to be_empty
321
      expect(subject.related_branches(user)).to eq([subject.to_branch_name])
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
322
    end
323 324

    it 'excludes stable branches from the related branches' do
325 326
      allow(subject.project.repository).to receive(:branch_names)
        .and_return(["#{subject.iid}-0-stable"])
327

328
      expect(subject.related_branches(user)).to eq []
329
    end
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
330 331
  end

332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
  describe '#has_related_branch?' do
    let(:issue) { create(:issue, title: "Blue Bell Knoll") }
    subject { issue.has_related_branch? }

    context 'branch found' do
      before do
        allow(issue.project.repository).to receive(:branch_names).and_return(["iceblink-luck", issue.to_branch_name])
      end

      it { is_expected.to eq true }
    end

    context 'branch not found' do
      before do
        allow(issue.project.repository).to receive(:branch_names).and_return(["lazy-calm"])
      end

      it { is_expected.to eq false }
    end
  end

353
  it_behaves_like 'an editable mentionable' do
354
    subject { create(:issue, project: create(:project, :repository)) }
355

356
    let(:backref_text) { "issue #{subject.to_reference}" }
357 358
    let(:set_mentionable_text) { ->(txt){ subject.description = txt } }
  end
Vinnie Okada's avatar
Vinnie Okada committed
359 360 361 362

  it_behaves_like 'a Taskable' do
    let(:subject) { create :issue }
  end
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
363 364

  describe "#to_branch_name" do
365
    let(:issue) { create(:issue, title: 'testing-issue') }
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
366

367
    it 'starts with the issue iid' do
368
      expect(issue.to_branch_name).to match /\A#{issue.iid}-[A-Za-z\-]+\z/
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
369
    end
370 371

    it "contains the issue title if not confidential" do
372
      expect(issue.to_branch_name).to match /testing-issue\z/
373 374 375 376
    end

    it "does not contain the issue title if confidential" do
      issue = create(:issue, title: 'testing-issue', confidential: true)
377
      expect(issue.to_branch_name).to match /confidential-issue\z/
378
    end
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
379
  end
Yorick Peterse's avatar
Yorick Peterse committed
380 381 382

  describe '#participants' do
    context 'using a public project' do
383
      let(:project) { create(:empty_project, :public) }
Yorick Peterse's avatar
Yorick Peterse committed
384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
      let(:issue) { create(:issue, project: project) }

      let!(:note1) do
        create(:note_on_issue, noteable: issue, project: project, note: 'a')
      end

      let!(:note2) do
        create(:note_on_issue, noteable: issue, project: project, note: 'b')
      end

      it 'includes the issue author' do
        expect(issue.participants).to include(issue.author)
      end

      it 'includes the authors of the notes' do
        expect(issue.participants).to include(note1.author, note2.author)
      end
    end

    context 'using a private project' do
      it 'does not include mentioned users that do not have access to the project' do
405
        project = create(:empty_project)
Yorick Peterse's avatar
Yorick Peterse committed
406 407 408 409 410 411 412 413 414 415 416 417
        user = create(:user)
        issue = create(:issue, project: project)

        create(:note_on_issue,
               noteable: issue,
               project: project,
               note: user.to_reference)

        expect(issue.participants).not_to include(user)
      end
    end
  end
418 419 420 421 422

  describe 'cached counts' do
    it 'updates when assignees change' do
      user1 = create(:user)
      user2 = create(:user)
423
      project = create(:empty_project)
424
      issue = create(:issue, assignees: [user1], project: project)
425 426
      project.add_developer(user1)
      project.add_developer(user2)
427 428 429 430

      expect(user1.assigned_open_issues_count).to eq(1)
      expect(user2.assigned_open_issues_count).to eq(0)

431
      issue.assignees = [user2]
432 433 434 435 436 437
      issue.save

      expect(user1.assigned_open_issues_count).to eq(0)
      expect(user2.assigned_open_issues_count).to eq(1)
    end
  end
438 439

  describe '#visible_to_user?' do
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
    context 'without a user' do
      let(:issue) { build(:issue) }

      it 'returns true when the issue is publicly visible' do
        expect(issue).to receive(:publicly_visible?).and_return(true)

        expect(issue.visible_to_user?).to eq(true)
      end

      it 'returns false when the issue is not publicly visible' do
        expect(issue).to receive(:publicly_visible?).and_return(false)

        expect(issue.visible_to_user?).to eq(false)
      end
    end

456
    context 'with a user' do
457
      let(:user) { create(:user) }
458 459 460 461 462 463 464 465 466 467 468 469 470 471
      let(:issue) { build(:issue) }

      it 'returns true when the issue is readable' do
        expect(issue).to receive(:readable_by?).with(user).and_return(true)

        expect(issue.visible_to_user?(user)).to eq(true)
      end

      it 'returns false when the issue is not readable' do
        expect(issue).to receive(:readable_by?).with(user).and_return(false)

        expect(issue.visible_to_user?(user)).to eq(false)
      end

472 473
      it 'returns false when feature is disabled' do
        expect(issue).not_to receive(:readable_by?)
474

475
        issue.project.project_feature.update_attribute(:issues_access_level, ProjectFeature::DISABLED)
476

477
        expect(issue.visible_to_user?(user)).to eq(false)
478 479
      end

480 481
      it 'returns false when restricted for members' do
        expect(issue).not_to receive(:readable_by?)
482

483 484 485
        issue.project.project_feature.update_attribute(:issues_access_level, ProjectFeature::PRIVATE)

        expect(issue.visible_to_user?(user)).to eq(false)
486 487 488 489 490 491 492 493 494 495 496 497
      end
    end

    describe 'with a regular user that is not a team member' do
      let(:user) { create(:user) }

      context 'using a public project' do
        let(:project) { create(:empty_project, :public) }

        it 'returns true for a regular issue' do
          issue = build(:issue, project: project)

498
          expect(issue.visible_to_user?(user)).to eq(true)
499 500 501 502 503
        end

        it 'returns false for a confidential issue' do
          issue = build(:issue, project: project, confidential: true)

504
          expect(issue.visible_to_user?(user)).to eq(false)
505 506 507 508 509 510 511 512 513 514
        end
      end

      context 'using an internal project' do
        let(:project) { create(:empty_project, :internal) }

        context 'using an internal user' do
          it 'returns true for a regular issue' do
            issue = build(:issue, project: project)

515
            expect(issue.visible_to_user?(user)).to eq(true)
516 517 518 519 520
          end

          it 'returns false for a confidential issue' do
            issue = build(:issue, :confidential, project: project)

521
            expect(issue.visible_to_user?(user)).to eq(false)
522 523 524 525 526 527 528 529 530 531 532
          end
        end

        context 'using an external user' do
          before do
            allow(user).to receive(:external?).and_return(true)
          end

          it 'returns false for a regular issue' do
            issue = build(:issue, project: project)

533
            expect(issue.visible_to_user?(user)).to eq(false)
534 535 536 537 538
          end

          it 'returns false for a confidential issue' do
            issue = build(:issue, :confidential, project: project)

539
            expect(issue.visible_to_user?(user)).to eq(false)
540 541 542 543 544 545 546 547 548 549
          end
        end
      end

      context 'using a private project' do
        let(:project) { create(:empty_project, :private) }

        it 'returns false for a regular issue' do
          issue = build(:issue, project: project)

550
          expect(issue.visible_to_user?(user)).to eq(false)
551 552 553 554 555
        end

        it 'returns false for a confidential issue' do
          issue = build(:issue, :confidential, project: project)

556
          expect(issue.visible_to_user?(user)).to eq(false)
557 558 559
        end

        context 'when the user is the project owner' do
560 561 562
          before do
            project.team << [user, :master]
          end
563

564 565 566
          it 'returns true for a regular issue' do
            issue = build(:issue, project: project)

567
            expect(issue.visible_to_user?(user)).to eq(true)
568 569 570 571 572
          end

          it 'returns true for a confidential issue' do
            issue = build(:issue, :confidential, project: project)

573
            expect(issue.visible_to_user?(user)).to eq(true)
574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
          end
        end
      end
    end

    context 'with a regular user that is a team member' do
      let(:user) { create(:user) }
      let(:project) { create(:empty_project, :public) }

      context 'using a public project' do
        before do
          project.team << [user, Gitlab::Access::DEVELOPER]
        end

        it 'returns true for a regular issue' do
          issue = build(:issue, project: project)

591
          expect(issue.visible_to_user?(user)).to eq(true)
592 593 594 595 596
        end

        it 'returns true for a confidential issue' do
          issue = build(:issue, :confidential, project: project)

597
          expect(issue.visible_to_user?(user)).to eq(true)
598 599 600 601 602 603 604 605 606 607 608 609 610
        end
      end

      context 'using an internal project' do
        let(:project) { create(:empty_project, :internal) }

        before do
          project.team << [user, Gitlab::Access::DEVELOPER]
        end

        it 'returns true for a regular issue' do
          issue = build(:issue, project: project)

611
          expect(issue.visible_to_user?(user)).to eq(true)
612 613 614 615 616
        end

        it 'returns true for a confidential issue' do
          issue = build(:issue, :confidential, project: project)

617
          expect(issue.visible_to_user?(user)).to eq(true)
618 619 620 621 622 623 624 625 626 627 628 629 630
        end
      end

      context 'using a private project' do
        let(:project) { create(:empty_project, :private) }

        before do
          project.team << [user, Gitlab::Access::DEVELOPER]
        end

        it 'returns true for a regular issue' do
          issue = build(:issue, project: project)

631
          expect(issue.visible_to_user?(user)).to eq(true)
632 633 634 635 636
        end

        it 'returns true for a confidential issue' do
          issue = build(:issue, :confidential, project: project)

637
          expect(issue.visible_to_user?(user)).to eq(true)
638 639 640 641 642 643
        end
      end
    end

    context 'with an admin user' do
      let(:project) { create(:empty_project) }
644
      let(:user) { create(:admin) }
645 646 647 648

      it 'returns true for a regular issue' do
        issue = build(:issue, project: project)

649
        expect(issue.visible_to_user?(user)).to eq(true)
650 651 652 653 654
      end

      it 'returns true for a confidential issue' do
        issue = build(:issue, :confidential, project: project)

655
        expect(issue.visible_to_user?(user)).to eq(true)
656 657 658 659 660 661 662 663 664 665 666
      end
    end
  end

  describe '#publicly_visible?' do
    context 'using a public project' do
      let(:project) { create(:empty_project, :public) }

      it 'returns true for a regular issue' do
        issue = build(:issue, project: project)

667
        expect(issue).to be_truthy
668 669 670 671 672
      end

      it 'returns false for a confidential issue' do
        issue = build(:issue, :confidential, project: project)

673
        expect(issue).not_to be_falsy
674 675 676 677 678 679 680 681 682
      end
    end

    context 'using an internal project' do
      let(:project) { create(:empty_project, :internal) }

      it 'returns false for a regular issue' do
        issue = build(:issue, project: project)

683
        expect(issue).not_to be_falsy
684 685 686 687 688
      end

      it 'returns false for a confidential issue' do
        issue = build(:issue, :confidential, project: project)

689
        expect(issue).not_to be_falsy
690 691 692 693 694 695 696 697 698
      end
    end

    context 'using a private project' do
      let(:project) { create(:empty_project, :private) }

      it 'returns false for a regular issue' do
        issue = build(:issue, project: project)

699
        expect(issue).not_to be_falsy
700 701 702 703 704
      end

      it 'returns false for a confidential issue' do
        issue = build(:issue, :confidential, project: project)

705
        expect(issue).not_to be_falsy
706 707 708
      end
    end
  end
709 710 711 712 713 714 715 716 717 718

  describe '#hook_attrs' do
    let(:attrs_hash) { subject.hook_attrs }

    it 'includes time tracking attrs' do
      expect(attrs_hash).to include(:total_time_spent)
      expect(attrs_hash).to include(:human_time_estimate)
      expect(attrs_hash).to include(:human_total_time_spent)
      expect(attrs_hash).to include('time_estimate')
    end
719 720 721 722 723

    it 'includes assignee_ids and deprecated assignee_id' do
      expect(attrs_hash).to include(:assignee_id)
      expect(attrs_hash).to include(:assignee_ids)
    end
724
  end
725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761

  describe '#check_for_spam' do
    let(:project) { create :project, visibility_level: visibility_level }
    let(:issue) { create :issue, project: project }

    subject do
      issue.assign_attributes(description: description)
      issue.check_for_spam?
    end

    context 'when project is public and spammable attributes changed' do
      let(:visibility_level) { Gitlab::VisibilityLevel::PUBLIC }
      let(:description) { 'woo' }

      it 'returns true' do
        is_expected.to be_truthy
      end
    end

    context 'when project is private' do
      let(:visibility_level) { Gitlab::VisibilityLevel::PRIVATE }
      let(:description) { issue.description }

      it 'returns false' do
        is_expected.to be_falsey
      end
    end

    context 'when spammable attributes have not changed' do
      let(:visibility_level) { Gitlab::VisibilityLevel::PUBLIC }
      let(:description) { issue.description }

      it 'returns false' do
        is_expected.to be_falsey
      end
    end
  end
gitlabhq's avatar
gitlabhq committed
762
end