2011-10-08 21:36:38 +00:00
|
|
|
require 'spec_helper'
|
|
|
|
|
2017-07-10 14:24:02 +00:00
|
|
|
describe Issue do
|
2011-10-08 21:36:38 +00:00
|
|
|
describe "Associations" do
|
2015-02-12 18:17:35 +00:00
|
|
|
it { is_expected.to belong_to(:milestone) }
|
2017-05-04 12:11:15 +00:00
|
|
|
it { is_expected.to have_many(:assignees) }
|
2011-10-08 21:36:38 +00:00
|
|
|
end
|
|
|
|
|
2012-08-29 05:52:19 +00:00
|
|
|
describe 'modules' do
|
2015-05-03 03:11:21 +00:00
|
|
|
subject { described_class }
|
|
|
|
|
2015-02-12 18:17:35 +00:00
|
|
|
it { is_expected.to include_module(Issuable) }
|
2015-05-03 03:11:21 +00:00
|
|
|
it { is_expected.to include_module(Referable) }
|
|
|
|
it { is_expected.to include_module(Sortable) }
|
|
|
|
it { is_expected.to include_module(Taskable) }
|
2018-03-13 18:43:02 +00:00
|
|
|
|
|
|
|
it_behaves_like 'AtomicInternalId' do
|
|
|
|
let(:internal_id_attribute) { :iid }
|
|
|
|
let(:instance) { build(:issue) }
|
2018-05-14 08:41:56 +00:00
|
|
|
let(:scope) { :project }
|
2018-03-13 18:43:02 +00:00
|
|
|
let(:scope_attrs) { { project: instance.project } }
|
|
|
|
let(:usage) { :issues }
|
|
|
|
end
|
2012-08-29 05:52:19 +00:00
|
|
|
end
|
|
|
|
|
2012-11-06 03:31:55 +00:00
|
|
|
subject { create(:issue) }
|
2012-05-20 18:15:13 +00:00
|
|
|
|
2017-12-07 17:41:30 +00:00
|
|
|
describe 'callbacks' do
|
|
|
|
describe '#ensure_metrics' do
|
|
|
|
it 'creates metrics after saving' do
|
|
|
|
issue = create(:issue)
|
|
|
|
|
|
|
|
expect(issue.metrics).to be_persisted
|
|
|
|
expect(Issue::Metrics.count).to eq(1)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'does not create duplicate metrics for an issue' do
|
|
|
|
issue = create(:issue)
|
|
|
|
|
|
|
|
issue.close!
|
|
|
|
|
|
|
|
expect(issue.metrics).to be_persisted
|
|
|
|
expect(Issue::Metrics.count).to eq(1)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'records current metrics' do
|
|
|
|
expect_any_instance_of(Issue::Metrics).to receive(:record!)
|
|
|
|
|
|
|
|
create(:issue)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-03-07 16:04:44 +00:00
|
|
|
describe '#order_by_position_and_priority' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create :project }
|
2017-03-07 16:04:44 +00:00
|
|
|
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
|
2017-06-21 13:48:12 +00:00
|
|
|
expect(project.issues.order_by_position_and_priority)
|
|
|
|
.to match [issue3, issue4, issue1, issue2]
|
2017-03-07 16:04:44 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-05-04 12:11:15 +00:00
|
|
|
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([])
|
|
|
|
|
2017-06-21 13:48:12 +00:00
|
|
|
expect(subject.card_attributes)
|
|
|
|
.to eq({ 'Author' => 'Robert', 'Assignee' => '' })
|
2017-05-04 12:11:15 +00:00
|
|
|
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')])
|
|
|
|
|
2017-06-21 13:48:12 +00:00
|
|
|
expect(subject.card_attributes)
|
|
|
|
.to eq({ 'Author' => 'Robert', 'Assignee' => 'Douwe' })
|
2017-05-04 12:11:15 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-09-24 14:14:11 +00:00
|
|
|
describe '#close' do
|
|
|
|
subject(:issue) { create(:issue, state: 'opened') }
|
2017-03-15 20:58:09 +00:00
|
|
|
|
2018-09-24 14:14:11 +00:00
|
|
|
it 'sets closed_at to Time.now when an issue is closed' do
|
|
|
|
expect { issue.close }.to change { issue.closed_at }.from(nil)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'changes the state to closed' do
|
|
|
|
expect { issue.close }.to change { issue.state }.from('opened').to('closed')
|
|
|
|
end
|
|
|
|
end
|
2017-08-11 10:36:03 +00:00
|
|
|
|
2018-09-24 14:14:11 +00:00
|
|
|
describe '#reopen' do
|
|
|
|
let(:user) { create(:user) }
|
|
|
|
let(:issue) { create(:issue, state: 'closed', closed_at: Time.now, closed_by: user) }
|
|
|
|
|
|
|
|
it 'sets closed_at to nil when an issue is reopend' do
|
|
|
|
expect { issue.reopen }.to change { issue.closed_at }.to(nil)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'sets closed_by to nil when an issue is reopend' do
|
|
|
|
expect { issue.reopen }.to change { issue.closed_by }.from(user).to(nil)
|
|
|
|
end
|
2017-03-15 20:58:09 +00:00
|
|
|
|
2018-09-24 14:14:11 +00:00
|
|
|
it 'changes the state to opened' do
|
|
|
|
expect { issue.reopen }.to change { issue.state }.from('closed').to('opened')
|
2017-03-15 20:58:09 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-05-03 03:11:21 +00:00
|
|
|
describe '#to_reference' do
|
2016-12-15 14:51:50 +00:00
|
|
|
let(:namespace) { build(:namespace, path: 'sample-namespace') }
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { build(:project, name: 'sample-project', namespace: namespace) }
|
2016-12-15 14:51:50 +00:00
|
|
|
let(:issue) { build(:issue, iid: 1, project: project) }
|
|
|
|
let(:group) { create(:group, name: 'Group', path: 'sample-group') }
|
2016-11-02 23:49:13 +00:00
|
|
|
|
2016-12-15 14:51:50 +00:00
|
|
|
context 'when nil argument' do
|
|
|
|
it 'returns issue id' do
|
|
|
|
expect(issue.to_reference).to eq "#1"
|
|
|
|
end
|
2016-12-15 12:50:28 +00:00
|
|
|
end
|
|
|
|
|
2017-01-10 23:52:25 +00:00
|
|
|
context 'when full is true' do
|
2016-12-15 14:51:50 +00:00
|
|
|
it 'returns complete path to the issue' do
|
2017-01-10 23:52:25 +00:00
|
|
|
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'
|
2016-12-15 14:51:50 +00:00
|
|
|
end
|
2015-05-03 03:11:21 +00:00
|
|
|
end
|
|
|
|
|
2016-12-15 14:51:50 +00:00
|
|
|
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
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:another_namespace_project) { create(:project, name: 'another-project') }
|
2016-12-15 14:51:50 +00:00
|
|
|
|
|
|
|
it 'returns complete path to the issue' do
|
|
|
|
expect(issue.to_reference(another_namespace_project)).to eq 'sample-namespace/sample-project#1'
|
|
|
|
end
|
2016-12-21 16:41:33 +00:00
|
|
|
end
|
|
|
|
|
2015-05-03 03:11:21 +00:00
|
|
|
it 'supports a cross-project reference' do
|
2017-08-02 19:55:11 +00:00
|
|
|
another_project = build(:project, name: 'another-project', namespace: project.namespace)
|
2016-11-02 23:49:13 +00:00
|
|
|
expect(issue.to_reference(another_project)).to eq "sample-project#1"
|
2015-05-03 03:11:21 +00:00
|
|
|
end
|
2016-12-15 12:50:28 +00:00
|
|
|
|
2016-12-15 14:51:50 +00:00
|
|
|
context 'when same namespace / cross-project argument' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:another_project) { create(:project, namespace: namespace) }
|
2016-12-15 14:51:50 +00:00
|
|
|
|
|
|
|
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') }
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:another_project) { create(:project, path: 'another-project', namespace: another_namespace) }
|
2016-12-15 14:51:50 +00:00
|
|
|
|
|
|
|
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
|
2016-12-15 12:50:28 +00:00
|
|
|
end
|
2015-05-03 03:11:21 +00:00
|
|
|
end
|
|
|
|
|
2017-05-04 12:11:15 +00:00
|
|
|
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
|
2012-05-20 18:15:13 +00:00
|
|
|
end
|
2017-05-04 12:11:15 +00:00
|
|
|
|
|
|
|
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
|
2012-05-20 18:15:13 +00:00
|
|
|
end
|
|
|
|
end
|
2013-02-18 09:41:32 +00:00
|
|
|
|
2016-03-17 10:11:22 +00:00
|
|
|
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
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project) }
|
2016-03-17 10:11:22 +00:00
|
|
|
let(:issue) { create(:issue, project: project) }
|
|
|
|
|
2017-06-14 18:18:56 +00:00
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
project.add_reporter(user)
|
2017-06-14 18:18:56 +00:00
|
|
|
end
|
2016-03-17 10:11:22 +00:00
|
|
|
|
|
|
|
it { is_expected.to eq true }
|
|
|
|
|
2016-03-23 08:39:37 +00:00
|
|
|
context 'issue not persisted' do
|
|
|
|
let(:issue) { build(:issue, project: project) }
|
|
|
|
it { is_expected.to eq false }
|
|
|
|
end
|
|
|
|
|
2016-03-17 10:11:22 +00:00
|
|
|
context 'checking destination project also' do
|
|
|
|
subject { issue.can_move?(user, to_project) }
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:to_project) { create(:project) }
|
2016-03-17 10:11:22 +00:00
|
|
|
|
|
|
|
context 'destination project allowed' do
|
2017-06-14 18:18:56 +00:00
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
to_project.add_reporter(user)
|
2017-06-14 18:18:56 +00:00
|
|
|
end
|
|
|
|
|
2016-03-17 10:11:22 +00:00
|
|
|
it { is_expected.to eq true }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'destination project not allowed' do
|
2017-06-14 18:18:56 +00:00
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
to_project.add_guest(user)
|
2017-06-14 18:18:56 +00:00
|
|
|
end
|
|
|
|
|
2016-03-17 10:11:22 +00:00
|
|
|
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
|
|
|
|
|
2018-04-05 15:17:02 +00:00
|
|
|
describe '#suggested_branch_name' do
|
|
|
|
let(:repository) { double }
|
|
|
|
|
|
|
|
subject { build(:issue) }
|
|
|
|
|
|
|
|
before do
|
|
|
|
allow(subject.project).to receive(:repository).and_return(repository)
|
|
|
|
end
|
|
|
|
|
|
|
|
context '#to_branch_name does not exists' do
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:branch_exists?).and_return(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns #to_branch_name' do
|
|
|
|
expect(subject.suggested_branch_name).to eq(subject.to_branch_name)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context '#to_branch_name exists not ending with -index' do
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:branch_exists?).and_return(true)
|
|
|
|
allow(repository).to receive(:branch_exists?).with(/#{subject.to_branch_name}-\d/).and_return(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns #to_branch_name ending with -2' do
|
|
|
|
expect(subject.suggested_branch_name).to eq("#{subject.to_branch_name}-2")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context '#to_branch_name exists ending with -index' do
|
|
|
|
before do
|
|
|
|
allow(repository).to receive(:branch_exists?).and_return(true)
|
|
|
|
allow(repository).to receive(:branch_exists?).with("#{subject.to_branch_name}-3").and_return(false)
|
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns #to_branch_name ending with max index + 1' do
|
|
|
|
expect(subject.suggested_branch_name).to eq("#{subject.to_branch_name}-3")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-05-04 08:09:21 +00:00
|
|
|
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
|
|
|
|
|
2013-05-30 23:16:49 +00:00
|
|
|
it_behaves_like 'an editable mentionable' do
|
2017-01-25 19:52:12 +00:00
|
|
|
subject { create(:issue, project: create(:project, :repository)) }
|
2015-04-16 20:25:25 +00:00
|
|
|
|
2015-06-18 00:40:26 +00:00
|
|
|
let(:backref_text) { "issue #{subject.to_reference}" }
|
2017-08-09 09:52:22 +00:00
|
|
|
let(:set_mentionable_text) { ->(txt) { subject.description = txt } }
|
2013-05-30 23:16:49 +00:00
|
|
|
end
|
2014-10-06 02:17:28 +00:00
|
|
|
|
|
|
|
it_behaves_like 'a Taskable' do
|
|
|
|
let(:subject) { create :issue }
|
|
|
|
end
|
2016-02-12 18:42:25 +00:00
|
|
|
|
|
|
|
describe "#to_branch_name" do
|
2016-04-12 10:31:44 +00:00
|
|
|
let(:issue) { create(:issue, title: 'testing-issue') }
|
2016-02-12 18:42:25 +00:00
|
|
|
|
2016-04-13 19:20:03 +00:00
|
|
|
it 'starts with the issue iid' do
|
2016-04-15 04:20:53 +00:00
|
|
|
expect(issue.to_branch_name).to match /\A#{issue.iid}-[A-Za-z\-]+\z/
|
2016-02-12 18:42:25 +00:00
|
|
|
end
|
2016-04-12 10:31:44 +00:00
|
|
|
|
|
|
|
it "contains the issue title if not confidential" do
|
2016-04-15 04:20:53 +00:00
|
|
|
expect(issue.to_branch_name).to match /testing-issue\z/
|
2016-04-12 10:31:44 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it "does not contain the issue title if confidential" do
|
|
|
|
issue = create(:issue, title: 'testing-issue', confidential: true)
|
2016-04-19 03:52:55 +00:00
|
|
|
expect(issue.to_branch_name).to match /confidential-issue\z/
|
2016-04-12 10:31:44 +00:00
|
|
|
end
|
2016-02-12 18:42:25 +00:00
|
|
|
end
|
2016-05-26 11:38:28 +00:00
|
|
|
|
2018-04-05 15:17:02 +00:00
|
|
|
describe '#can_be_worked_on?' do
|
|
|
|
let(:project) { build(:project) }
|
|
|
|
subject { build(:issue, :opened, project: project) }
|
|
|
|
|
|
|
|
context 'is closed' do
|
|
|
|
subject { build(:issue, :closed) }
|
|
|
|
|
|
|
|
it { is_expected.not_to be_can_be_worked_on }
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'project is forked' do
|
|
|
|
before do
|
|
|
|
allow(project).to receive(:forked?).and_return(true)
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.not_to be_can_be_worked_on }
|
|
|
|
end
|
|
|
|
|
|
|
|
it { is_expected.to be_can_be_worked_on }
|
|
|
|
end
|
|
|
|
|
2016-05-26 11:38:28 +00:00
|
|
|
describe '#participants' do
|
|
|
|
context 'using a public project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :public) }
|
2016-05-26 11:38:28 +00:00
|
|
|
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
|
2017-08-02 19:55:11 +00:00
|
|
|
project = create(:project)
|
2016-05-26 11:38:28 +00:00
|
|
|
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
|
2016-06-02 13:25:40 +00:00
|
|
|
|
|
|
|
describe 'cached counts' do
|
|
|
|
it 'updates when assignees change' do
|
|
|
|
user1 = create(:user)
|
|
|
|
user2 = create(:user)
|
2017-08-02 19:55:11 +00:00
|
|
|
project = create(:project)
|
2017-05-04 12:11:15 +00:00
|
|
|
issue = create(:issue, assignees: [user1], project: project)
|
2017-04-19 15:17:46 +00:00
|
|
|
project.add_developer(user1)
|
|
|
|
project.add_developer(user2)
|
2016-06-02 13:25:40 +00:00
|
|
|
|
|
|
|
expect(user1.assigned_open_issues_count).to eq(1)
|
|
|
|
expect(user2.assigned_open_issues_count).to eq(0)
|
|
|
|
|
2017-05-04 12:11:15 +00:00
|
|
|
issue.assignees = [user2]
|
2016-06-02 13:25:40 +00:00
|
|
|
issue.save
|
|
|
|
|
|
|
|
expect(user1.assigned_open_issues_count).to eq(0)
|
|
|
|
expect(user2.assigned_open_issues_count).to eq(1)
|
|
|
|
end
|
|
|
|
end
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
describe '#visible_to_user?' do
|
2016-11-01 20:18:51 +00:00
|
|
|
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
|
|
|
|
|
2016-07-20 18:13:02 +00:00
|
|
|
context 'with a user' do
|
2016-11-18 17:15:47 +00:00
|
|
|
let(:user) { create(:user) }
|
2016-07-20 18:13:02 +00:00
|
|
|
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
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
it 'returns false when feature is disabled' do
|
|
|
|
expect(issue).not_to receive(:readable_by?)
|
2016-07-20 18:13:02 +00:00
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
issue.project.project_feature.update_attribute(:issues_access_level, ProjectFeature::DISABLED)
|
2016-07-20 18:13:02 +00:00
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
it 'returns false when restricted for members' do
|
|
|
|
expect(issue).not_to receive(:readable_by?)
|
2016-07-20 18:13:02 +00:00
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
issue.project.project_feature.update_attribute(:issues_access_level, ProjectFeature::PRIVATE)
|
|
|
|
|
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe 'with a regular user that is not a team member' do
|
|
|
|
let(:user) { create(:user) }
|
|
|
|
|
|
|
|
context 'using a public project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :public) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, project: project, confidential: true)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using an internal project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :internal) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
context 'using an internal user' do
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
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)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using a private project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :private) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns false for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(false)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
context 'when the user is the project owner' do
|
2017-06-14 18:18:56 +00:00
|
|
|
before do
|
2018-07-11 14:36:08 +00:00
|
|
|
project.add_maintainer(user)
|
2017-06-14 18:18:56 +00:00
|
|
|
end
|
2016-11-01 20:18:51 +00:00
|
|
|
|
2016-07-20 18:13:02 +00:00
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with a regular user that is a team member' do
|
|
|
|
let(:user) { create(:user) }
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :public) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
context 'using a public project' do
|
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
project.add_developer(user)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using an internal project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :internal) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
project.add_developer(user)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using a private project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :private) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
before do
|
2017-12-22 08:18:28 +00:00
|
|
|
project.add_developer(user)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'with an admin user' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project) }
|
2016-09-16 15:54:21 +00:00
|
|
|
let(:user) { create(:admin) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns true for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue.visible_to_user?(user)).to eq(true)
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '#publicly_visible?' do
|
|
|
|
context 'using a public project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :public) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns true for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).to be_truthy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).not_to be_falsy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using an internal project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :internal) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns false for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).not_to be_falsy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).not_to be_falsy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
context 'using a private project' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create(:project, :private) }
|
2016-07-20 18:13:02 +00:00
|
|
|
|
|
|
|
it 'returns false for a regular issue' do
|
|
|
|
issue = build(:issue, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).not_to be_falsy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
it 'returns false for a confidential issue' do
|
|
|
|
issue = build(:issue, :confidential, project: project)
|
|
|
|
|
2016-11-01 20:18:51 +00:00
|
|
|
expect(issue).not_to be_falsy
|
2016-07-20 18:13:02 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2017-03-14 16:56:15 +00:00
|
|
|
|
|
|
|
describe '#hook_attrs' do
|
2017-10-05 17:02:50 +00:00
|
|
|
it 'delegates to Gitlab::HookData::IssueBuilder#build' do
|
|
|
|
builder = double
|
|
|
|
|
|
|
|
expect(Gitlab::HookData::IssueBuilder)
|
|
|
|
.to receive(:new).with(subject).and_return(builder)
|
|
|
|
expect(builder).to receive(:build)
|
|
|
|
|
|
|
|
subject.hook_attrs
|
2017-05-04 12:11:15 +00:00
|
|
|
end
|
2017-03-14 16:56:15 +00:00
|
|
|
end
|
2017-03-21 02:37:29 +00:00
|
|
|
|
|
|
|
describe '#check_for_spam' do
|
2017-08-02 19:55:11 +00:00
|
|
|
let(:project) { create :project, visibility_level: visibility_level }
|
2017-03-21 02:37:29 +00:00
|
|
|
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
|
2017-08-17 15:21:25 +00:00
|
|
|
|
|
|
|
describe 'removing an issue' do
|
|
|
|
it 'refreshes the number of open issues of the project' do
|
|
|
|
project = subject.project
|
|
|
|
|
|
|
|
expect { subject.destroy }
|
|
|
|
.to change { project.open_issues_count }.from(1).to(0)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
describe '.public_only' do
|
|
|
|
it 'only returns public issues' do
|
|
|
|
public_issue = create(:issue)
|
|
|
|
create(:issue, confidential: true)
|
|
|
|
|
|
|
|
expect(described_class.public_only).to eq([public_issue])
|
|
|
|
end
|
|
|
|
end
|
2017-12-01 13:52:16 +00:00
|
|
|
|
|
|
|
it_behaves_like 'throttled touch' do
|
|
|
|
subject { create(:issue, updated_at: 1.hour.ago) }
|
|
|
|
end
|
2011-10-08 21:36:38 +00:00
|
|
|
end
|