BigW Consortium Gitlab

note_spec.rb 11.4 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 45
        build(:note, noteable: build_stubbed(:issue),
                     project: build_stubbed(: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
gitlabhq committed
55 56
  end

57
  describe "Commit notes" do
Riyad Preukschas committed
58 59
    let!(:note) { create(:note_on_commit, note: "+1 from me") }
    let!(:commit) { note.noteable }
60

61
    it "is accessible through #noteable" do
62 63 64
      expect(note.commit_id).to eq(commit.id)
      expect(note.noteable).to be_a(Commit)
      expect(note.noteable).to eq(commit)
65 66
    end

67
    it "saves a valid note" do
68
      expect(note.commit_id).to eq(commit.id)
Riyad Preukschas committed
69
      note.noteable == commit
70 71
    end

72
    it "is recognized by #for_commit?" do
73
      expect(note).to be_for_commit
74
    end
75 76 77 78

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

81
  describe 'authorization' do
Nihad Abbasov committed
82
    before do
83
      @p1 = create(:project)
84 85 86 87
      @p2 = create(:project)
      @u1 = create(:user)
      @u2 = create(:user)
      @u3 = create(:user)
gitlabhq committed
88 89
    end

90
    describe 'read' do
Nihad Abbasov committed
91
      before do
92 93
        @p1.project_members.create(user: @u2, access_level: ProjectMember::GUEST)
        @p2.project_members.create(user: @u3, access_level: ProjectMember::GUEST)
gitlabhq committed
94 95
      end

96 97 98
      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
99 100
    end

101
    describe 'write' do
Nihad Abbasov committed
102
      before do
103 104
        @p1.project_members.create(user: @u2, access_level: ProjectMember::DEVELOPER)
        @p2.project_members.create(user: @u3, access_level: ProjectMember::DEVELOPER)
gitlabhq committed
105 106
      end

107 108 109
      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
110 111
    end

112
    describe 'admin' do
Nihad Abbasov committed
113
      before do
114 115 116
        @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
117 118
      end

119 120 121
      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
122 123
    end
  end
124 125

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

Douwe Maan committed
128
    let(:issue) { create :issue }
129 130 131
    let(:backref_text) { issue.gfm_reference }
    let(:set_mentionable_text) { ->(txt) { subject.note = txt } }
  end
132

Douwe Maan committed
133
  describe "#all_references" do
134 135
    let!(:note1) { create(:note_on_issue) }
    let!(:note2) { create(:note_on_issue) }
Douwe Maan committed
136 137

    it "reads the rendered note body from the cache" do
138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
      expect(Banzai::Renderer).to receive(:cache_collection_render).
        with([{
          text: note1.note,
          context: {
            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: {
            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
162 163 164
    end
  end

165
  describe '.search' do
166
    let(:note) { create(:note_on_issue, note: 'WoW') }
167

168 169 170 171 172 173 174
    it 'returns notes with matching content' do
      expect(described_class.search(note.note)).to eq([note])
    end

    it 'returns notes with matching content regardless of the casing' do
      expect(described_class.search('WOW')).to eq([note])
    end
175 176

    context "confidential issues" do
177 178 179 180
      let(:user) { create(:user) }
      let(:project) { create(:project) }
      let(:confidential_issue) { create(:issue, :confidential, project: project, author: user) }
      let(:confidential_note) { create(:note, note: "Random", noteable: confidential_issue, project: confidential_issue.project) }
181 182 183 184 185 186

      it "returns notes with matching content if user can see the issue" do
        expect(described_class.search(confidential_note.note, as_user: user)).to eq([confidential_note])
      end

      it "does not return notes with matching content if user can not see the issue" do
187 188 189 190 191 192 193
        user = create(:user)
        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
      end

      it "does not return notes with matching content for project members with guest role" do
        user = create(:user)
        project.team << [user, :guest]
194 195 196 197 198 199 200
        expect(described_class.search(confidential_note.note, as_user: user)).to be_empty
      end

      it "does not return notes with matching content for unauthenticated users" do
        expect(described_class.search(confidential_note.note)).to be_empty
      end
    end
201
  end
Valery Sizov committed
202

203 204 205 206 207 208 209 210 211 212 213
  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
214

215 216 217 218 219 220 221 222
  describe "cross_reference_not_visible_for?" do
    let(:private_user)    { create(:user) }
    let(:private_project) { create(:project, namespace: private_user.namespace).tap { |p| p.team << [private_user, :master] } }
    let(:private_issue)   { create(:issue, project: private_project) }

    let(:ext_proj)  { create(:project, :public) }
    let(:ext_issue) { create(:issue, project: ext_proj) }

223
    let(:note) do
224 225
      create :note,
        noteable: ext_issue, project: ext_proj,
226
        note: "mentioned in issue #{private_issue.to_reference(ext_proj)}",
227
        system: true
228
    end
229 230 231 232 233 234 235 236

    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
237 238 239 240 241 242 243 244 245 246 247 248 249 250

    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
251 252
  end

253 254 255 256 257 258 259
  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
260 261 262 263 264 265 266 267 268 269

  describe '#participants' do
    it 'includes the note author' do
      project = create(:project, :public)
      issue = create(:issue, project: project)
      note = create(:note_on_issue, noteable: issue, project: project)

      expect(note.participants).to include(note.author)
    end
  end
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321

  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) }
    let!(:active_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
    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) }
    let!(:outdated_diff_note2) { create(:diff_note_on_merge_request, project: project, noteable: merge_request, position: outdated_position) }

    let(:active_position2) do
      Gitlab::Diff::Position.new(
        old_path: "files/ruby/popen.rb",
        new_path: "files/ruby/popen.rb",
        old_line: 16,
        new_line: 22,
        diff_refs: merge_request.diff_refs
      )
    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

    subject { merge_request.notes.grouped_diff_discussions }

    it "includes active discussions" do
      discussions = subject.values

      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

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

    it "doesn't include outdated discussions" do
      expect(subject.values.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].id).to eq(active_diff_note1.discussion_id)
      expect(subject[active_diff_note3.line_code].id).to eq(active_diff_note3.discussion_id)
    end
  end
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

  describe "#discussion_id" do
    let(:note) { create(:note) }

    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
  end
gitlabhq committed
347
end