f928dba99b
Previously the `truncated_diff_lines` method for outputting a discussion diff took in already highlighted lines, which meant it wasn't reuseable for truncating ANY lines. In the way it was used, it also meant that for any email truncation, the whole diff was being highlighted before being truncated, meaning wasted time highlighting lines that wouldn't even be used (granted, they were being memoized, so perhaps this wasn't that great of an issue). I refactored truncation away from highlighting, in order to truncate formatted diffs for text templates in email, using `>`s to designate each line, but otherwise retaining the parsing already done to create `diff_lines`. Additionally, while notes on merge requests or commits had already been tested, there was no existing test for notes on a diff on an MR or commit. Added mailer tests for such, and a unit test for truncating diff lines.
618 lines
17 KiB
Ruby
618 lines
17 KiB
Ruby
require 'spec_helper'
|
|
|
|
describe Discussion, model: true do
|
|
subject { described_class.new([first_note, second_note, third_note]) }
|
|
|
|
let(:first_note) { create(:diff_note_on_merge_request) }
|
|
let(:second_note) { create(:diff_note_on_merge_request) }
|
|
let(:third_note) { create(:diff_note_on_merge_request) }
|
|
|
|
describe "#resolvable?" do
|
|
context "when a diff discussion" do
|
|
before do
|
|
allow(subject).to receive(:diff_discussion?).and_return(true)
|
|
end
|
|
|
|
context "when all notes are unresolvable" do
|
|
before do
|
|
allow(first_note).to receive(:resolvable?).and_return(false)
|
|
allow(second_note).to receive(:resolvable?).and_return(false)
|
|
allow(third_note).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.resolvable?).to be false
|
|
end
|
|
end
|
|
|
|
context "when some notes are unresolvable and some notes are resolvable" do
|
|
before do
|
|
allow(first_note).to receive(:resolvable?).and_return(true)
|
|
allow(second_note).to receive(:resolvable?).and_return(false)
|
|
allow(third_note).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.resolvable?).to be true
|
|
end
|
|
end
|
|
|
|
context "when all notes are resolvable" do
|
|
before do
|
|
allow(first_note).to receive(:resolvable?).and_return(true)
|
|
allow(second_note).to receive(:resolvable?).and_return(true)
|
|
allow(third_note).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.resolvable?).to be true
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when not a diff discussion" do
|
|
before do
|
|
allow(subject).to receive(:diff_discussion?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.resolvable?).to be false
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#resolved?" do
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.resolved?).to be false
|
|
end
|
|
end
|
|
|
|
context "when resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
|
|
allow(first_note).to receive(:resolvable?).and_return(true)
|
|
allow(second_note).to receive(:resolvable?).and_return(false)
|
|
allow(third_note).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when all resolvable notes are resolved" do
|
|
before do
|
|
allow(first_note).to receive(:resolved?).and_return(true)
|
|
allow(third_note).to receive(:resolved?).and_return(true)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.resolved?).to be true
|
|
end
|
|
end
|
|
|
|
context "when some resolvable notes are not resolved" do
|
|
before do
|
|
allow(first_note).to receive(:resolved?).and_return(true)
|
|
allow(third_note).to receive(:resolved?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.resolved?).to be false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#to_be_resolved?" do
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.to_be_resolved?).to be false
|
|
end
|
|
end
|
|
|
|
context "when resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
|
|
allow(first_note).to receive(:resolvable?).and_return(true)
|
|
allow(second_note).to receive(:resolvable?).and_return(false)
|
|
allow(third_note).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when all resolvable notes are resolved" do
|
|
before do
|
|
allow(first_note).to receive(:resolved?).and_return(true)
|
|
allow(third_note).to receive(:resolved?).and_return(true)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.to_be_resolved?).to be false
|
|
end
|
|
end
|
|
|
|
context "when some resolvable notes are not resolved" do
|
|
before do
|
|
allow(first_note).to receive(:resolved?).and_return(true)
|
|
allow(third_note).to receive(:resolved?).and_return(false)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.to_be_resolved?).to be true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#can_resolve?" do
|
|
let(:current_user) { create(:user) }
|
|
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.can_resolve?(current_user)).to be false
|
|
end
|
|
end
|
|
|
|
context "when resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when not signed in" do
|
|
let(:current_user) { nil }
|
|
|
|
it "returns false" do
|
|
expect(subject.can_resolve?(current_user)).to be false
|
|
end
|
|
end
|
|
|
|
context "when signed in" do
|
|
context "when the signed in user is the noteable author" do
|
|
before do
|
|
subject.noteable.author = current_user
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.can_resolve?(current_user)).to be true
|
|
end
|
|
end
|
|
|
|
context "when the signed in user can push to the project" do
|
|
before do
|
|
subject.project.team << [current_user, :master]
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.can_resolve?(current_user)).to be true
|
|
end
|
|
end
|
|
|
|
context "when the signed in user is a random user" do
|
|
it "returns false" do
|
|
expect(subject.can_resolve?(current_user)).to be false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#resolve!" do
|
|
let(:current_user) { create(:user) }
|
|
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns nil" do
|
|
expect(subject.resolve!(current_user)).to be_nil
|
|
end
|
|
|
|
it "doesn't set resolved_at" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved_at).to be_nil
|
|
end
|
|
|
|
it "doesn't set resolved_by" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved_by).to be_nil
|
|
end
|
|
|
|
it "doesn't mark as resolved" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved?).to be false
|
|
end
|
|
end
|
|
|
|
context "when resolvable" do
|
|
let(:user) { create(:user) }
|
|
let(:second_note) { create(:diff_note_on_commit) } # unresolvable
|
|
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when all resolvable notes are resolved" do
|
|
before do
|
|
first_note.resolve!(user)
|
|
third_note.resolve!(user)
|
|
|
|
first_note.reload
|
|
third_note.reload
|
|
end
|
|
|
|
it "doesn't change resolved_at on the resolved notes" do
|
|
expect(first_note.resolved_at).not_to be_nil
|
|
expect(third_note.resolved_at).not_to be_nil
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_at }
|
|
expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_at }
|
|
end
|
|
|
|
it "doesn't change resolved_by on the resolved notes" do
|
|
expect(first_note.resolved_by).to eq(user)
|
|
expect(third_note.resolved_by).to eq(user)
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { first_note.resolved_by }
|
|
expect { subject.resolve!(current_user) }.not_to change { third_note.resolved_by }
|
|
end
|
|
|
|
it "doesn't change the resolved state on the resolved notes" do
|
|
expect(first_note.resolved?).to be true
|
|
expect(third_note.resolved?).to be true
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { first_note.resolved? }
|
|
expect { subject.resolve!(current_user) }.not_to change { third_note.resolved? }
|
|
end
|
|
|
|
it "doesn't change resolved_at" do
|
|
expect(subject.resolved_at).not_to be_nil
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { subject.resolved_at }
|
|
end
|
|
|
|
it "doesn't change resolved_by" do
|
|
expect(subject.resolved_by).to eq(user)
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { subject.resolved_by }
|
|
end
|
|
|
|
it "doesn't change resolved state" do
|
|
expect(subject.resolved?).to be true
|
|
|
|
expect { subject.resolve!(current_user) }.not_to change { subject.resolved? }
|
|
end
|
|
end
|
|
|
|
context "when some resolvable notes are resolved" do
|
|
before do
|
|
first_note.resolve!(user)
|
|
end
|
|
|
|
it "doesn't change resolved_at on the resolved note" do
|
|
expect(first_note.resolved_at).not_to be_nil
|
|
|
|
expect { subject.resolve!(current_user) }.
|
|
not_to change { first_note.reload.resolved_at }
|
|
end
|
|
|
|
it "doesn't change resolved_by on the resolved note" do
|
|
expect(first_note.resolved_by).to eq(user)
|
|
|
|
expect { subject.resolve!(current_user) }.
|
|
not_to change { first_note.reload && first_note.resolved_by }
|
|
end
|
|
|
|
it "doesn't change the resolved state on the resolved note" do
|
|
expect(first_note.resolved?).to be true
|
|
|
|
expect { subject.resolve!(current_user) }.
|
|
not_to change { first_note.reload && first_note.resolved? }
|
|
end
|
|
|
|
it "sets resolved_at on the unresolved note" do
|
|
subject.resolve!(current_user)
|
|
third_note.reload
|
|
|
|
expect(third_note.resolved_at).not_to be_nil
|
|
end
|
|
|
|
it "sets resolved_by on the unresolved note" do
|
|
subject.resolve!(current_user)
|
|
third_note.reload
|
|
|
|
expect(third_note.resolved_by).to eq(current_user)
|
|
end
|
|
|
|
it "marks the unresolved note as resolved" do
|
|
subject.resolve!(current_user)
|
|
third_note.reload
|
|
|
|
expect(third_note.resolved?).to be true
|
|
end
|
|
|
|
it "sets resolved_at" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved_at).not_to be_nil
|
|
end
|
|
|
|
it "sets resolved_by" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved_by).to eq(current_user)
|
|
end
|
|
|
|
it "marks as resolved" do
|
|
subject.resolve!(current_user)
|
|
|
|
expect(subject.resolved?).to be true
|
|
end
|
|
end
|
|
|
|
context "when no resolvable notes are resolved" do
|
|
it "sets resolved_at on the unresolved notes" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved_at).not_to be_nil
|
|
expect(third_note.resolved_at).not_to be_nil
|
|
end
|
|
|
|
it "sets resolved_by on the unresolved notes" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved_by).to eq(current_user)
|
|
expect(third_note.resolved_by).to eq(current_user)
|
|
end
|
|
|
|
it "marks the unresolved notes as resolved" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved?).to be true
|
|
expect(third_note.resolved?).to be true
|
|
end
|
|
|
|
it "sets resolved_at" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(subject.resolved_at).not_to be_nil
|
|
end
|
|
|
|
it "sets resolved_by" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(subject.resolved_by).to eq(current_user)
|
|
end
|
|
|
|
it "marks as resolved" do
|
|
subject.resolve!(current_user)
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(subject.resolved?).to be true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#unresolve!" do
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
it "returns nil" do
|
|
expect(subject.unresolve!).to be_nil
|
|
end
|
|
end
|
|
|
|
context "when resolvable" do
|
|
let(:user) { create(:user) }
|
|
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
|
|
allow(first_note).to receive(:resolvable?).and_return(true)
|
|
allow(second_note).to receive(:resolvable?).and_return(false)
|
|
allow(third_note).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when all resolvable notes are resolved" do
|
|
before do
|
|
first_note.resolve!(user)
|
|
third_note.resolve!(user)
|
|
end
|
|
|
|
it "unsets resolved_at on the resolved notes" do
|
|
subject.unresolve!
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved_at).to be_nil
|
|
expect(third_note.resolved_at).to be_nil
|
|
end
|
|
|
|
it "unsets resolved_by on the resolved notes" do
|
|
subject.unresolve!
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved_by).to be_nil
|
|
expect(third_note.resolved_by).to be_nil
|
|
end
|
|
|
|
it "unmarks the resolved notes as resolved" do
|
|
subject.unresolve!
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(first_note.resolved?).to be false
|
|
expect(third_note.resolved?).to be false
|
|
end
|
|
|
|
it "unsets resolved_at" do
|
|
subject.unresolve!
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(subject.resolved_at).to be_nil
|
|
end
|
|
|
|
it "unsets resolved_by" do
|
|
subject.unresolve!
|
|
first_note.reload
|
|
third_note.reload
|
|
|
|
expect(subject.resolved_by).to be_nil
|
|
end
|
|
|
|
it "unmarks as resolved" do
|
|
subject.unresolve!
|
|
|
|
expect(subject.resolved?).to be false
|
|
end
|
|
end
|
|
|
|
context "when some resolvable notes are resolved" do
|
|
before do
|
|
first_note.resolve!(user)
|
|
end
|
|
|
|
it "unsets resolved_at on the resolved note" do
|
|
subject.unresolve!
|
|
|
|
expect(subject.first_note.resolved_at).to be_nil
|
|
end
|
|
|
|
it "unsets resolved_by on the resolved note" do
|
|
subject.unresolve!
|
|
|
|
expect(subject.first_note.resolved_by).to be_nil
|
|
end
|
|
|
|
it "unmarks the resolved note as resolved" do
|
|
subject.unresolve!
|
|
|
|
expect(subject.first_note.resolved?).to be false
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#collapsed?" do
|
|
context "when a diff discussion" do
|
|
before do
|
|
allow(subject).to receive(:diff_discussion?).and_return(true)
|
|
end
|
|
|
|
context "when resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(true)
|
|
end
|
|
|
|
context "when resolved" do
|
|
before do
|
|
allow(subject).to receive(:resolved?).and_return(true)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.collapsed?).to be true
|
|
end
|
|
end
|
|
|
|
context "when not resolved" do
|
|
before do
|
|
allow(subject).to receive(:resolved?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.collapsed?).to be false
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when not resolvable" do
|
|
before do
|
|
allow(subject).to receive(:resolvable?).and_return(false)
|
|
end
|
|
|
|
context "when active" do
|
|
before do
|
|
allow(subject).to receive(:active?).and_return(true)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.collapsed?).to be false
|
|
end
|
|
end
|
|
|
|
context "when outdated" do
|
|
before do
|
|
allow(subject).to receive(:active?).and_return(false)
|
|
end
|
|
|
|
it "returns true" do
|
|
expect(subject.collapsed?).to be true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when not a diff discussion" do
|
|
before do
|
|
allow(subject).to receive(:diff_discussion?).and_return(false)
|
|
end
|
|
|
|
it "returns false" do
|
|
expect(subject.collapsed?).to be false
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#truncated_diff_lines" do
|
|
let(:truncated_lines) { subject.truncated_diff_lines }
|
|
|
|
context "when diff is greater than allowed number of truncated diff lines " do
|
|
let(:initial_line_count) { subject.diff_file.diff_lines.count }
|
|
let(:truncated_line_count) { truncated_lines.count }
|
|
|
|
it "returns fewer lines" do
|
|
expect(initial_line_count).to be > described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
|
|
|
|
expect(truncated_line_count).to be <= described_class::NUMBER_OF_TRUNCATED_DIFF_LINES
|
|
end
|
|
end
|
|
|
|
context "when some diff lines are meta" do
|
|
let(:initial_meta_lines?) { subject.diff_file.diff_lines.any?(&:meta?) }
|
|
let(:truncated_meta_lines?) { truncated_lines.any?(&:meta?) }
|
|
|
|
it "returns no meta lines" do
|
|
expect(initial_meta_lines?).to be true
|
|
expect(truncated_meta_lines?).to be false
|
|
end
|
|
end
|
|
end
|
|
end
|