debian-mirror-gitlab/spec/services/notification_service_spec.rb

1841 lines
63 KiB
Ruby
Raw Normal View History

2014-09-02 18:07:02 +05:30
require 'spec_helper'
2017-09-10 17:25:29 +05:30
describe NotificationService, :mailer do
2018-03-17 18:26:18 +05:30
include EmailSpec::Matchers
2017-09-10 17:25:29 +05:30
let(:notification) { described_class.new }
2017-08-17 22:00:37 +05:30
let(:assignee) { create(:user) }
2014-09-02 18:07:02 +05:30
2018-03-17 18:26:18 +05:30
around do |example|
2015-12-23 02:04:40 +05:30
perform_enqueued_jobs do
example.run
end
end
2016-09-13 17:45:13 +05:30
shared_examples 'notifications for new mentions' do
def send_notifications(*new_mentions)
2018-03-17 18:26:18 +05:30
mentionable.description = new_mentions.map(&:to_reference).join(' ')
2016-09-13 17:45:13 +05:30
notification.send(notification_method, mentionable, new_mentions, @u_disabled)
end
it 'sends no emails when no new mentions are present' do
send_notifications
2017-08-17 22:00:37 +05:30
should_not_email_anyone
2016-09-13 17:45:13 +05:30
end
2018-03-17 18:26:18 +05:30
it 'emails new mentions with a watch level higher than mention' do
send_notifications(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned)
should_only_email(@u_watcher, @u_participant_mentioned, @u_custom_global, @u_mentioned)
2016-09-13 17:45:13 +05:30
end
2018-03-17 18:26:18 +05:30
it 'does not email new mentions with a watch level equal to or less than mention' do
send_notifications(@u_disabled)
2017-08-17 22:00:37 +05:30
should_not_email_anyone
end
2018-03-17 18:26:18 +05:30
it 'sends the proper notification reason header' do
send_notifications(@u_watcher)
should_only_email(@u_watcher)
email = find_email_for(@u_watcher)
expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::MENTIONED)
end
2017-08-17 22:00:37 +05:30
end
# Next shared examples are intended to test notifications of "participants"
#
# they take the following parameters:
# * issuable
# * notification trigger
# * participant
#
shared_examples 'participating by note notification' do
it 'emails the participant' do
create(:note_on_issue, noteable: issuable, project_id: project.id, note: 'anything', author: participant)
notification_trigger
should_email(participant)
end
end
shared_examples 'participating by assignee notification' do
it 'emails the participant' do
if issuable.is_a?(Issue)
issuable.assignees << participant
else
issuable.update_attribute(:assignee, participant)
end
notification_trigger
should_email(participant)
end
end
shared_examples 'participating by author notification' do
it 'emails the participant' do
issuable.author = participant
notification_trigger
should_email(participant)
2016-09-13 17:45:13 +05:30
end
end
2017-08-17 22:00:37 +05:30
shared_examples_for 'participating notifications' do
it_should_behave_like 'participating by note notification'
it_should_behave_like 'participating by author notification'
it_should_behave_like 'participating by assignee notification'
end
2014-09-02 18:07:02 +05:30
describe 'Keys' do
2016-06-02 11:05:42 +05:30
describe '#new_key' do
2018-03-17 18:26:18 +05:30
let(:key_options) { {} }
let!(:key) { create(:personal_key, key_options) }
2014-09-02 18:07:02 +05:30
2015-04-26 12:48:37 +05:30
it { expect(notification.new_key(key)).to be_truthy }
2014-09-02 18:07:02 +05:30
2018-03-17 18:26:18 +05:30
describe 'never emails the ghost user' do
let(:key_options) { { user: User.ghost } }
it { should_not_email_anyone }
2014-09-02 18:07:02 +05:30
end
end
end
2017-09-10 17:25:29 +05:30
describe 'GpgKeys' do
describe '#new_gpg_key' do
let!(:key) { create(:gpg_key) }
it { expect(notification.new_gpg_key(key)).to be_truthy }
it 'sends email to key owner' do
2018-03-17 18:26:18 +05:30
expect { notification.new_gpg_key(key) }.to change { ActionMailer::Base.deliveries.size }.by(1)
2014-09-02 18:07:02 +05:30
end
end
end
describe 'Notes' do
context 'issue note' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project, :private) }
2017-08-17 22:00:37 +05:30
let(:issue) { create(:issue, project: project, assignees: [assignee]) }
let(:mentioned_issue) { create(:issue, assignees: issue.assignees) }
2015-09-25 12:07:36 +05:30
let(:note) { create(:note_on_issue, noteable: issue, project_id: issue.project_id, note: '@mention referenced, @outsider also') }
2014-09-02 18:07:02 +05:30
before do
build_team(note.project)
2017-08-17 22:00:37 +05:30
project.add_master(issue.author)
project.add_master(assignee)
project.add_master(note.author)
2017-09-10 17:25:29 +05:30
@u_custom_off = create_user_with_notification(:custom, 'custom_off')
project.add_guest(@u_custom_off)
create(
:note_on_issue,
author: @u_custom_off,
noteable: issue,
project_id: issue.project_id,
note: 'i think @subscribed_participant should see this'
)
2017-08-17 22:00:37 +05:30
update_custom_notification(:new_note, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:new_note, @u_custom_global)
2014-09-02 18:07:02 +05:30
end
2016-08-24 12:49:21 +05:30
describe '#new_note' do
2014-09-02 18:07:02 +05:30
it do
2015-04-26 12:48:37 +05:30
add_users_with_subscription(note.project, issue)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2015-04-26 12:48:37 +05:30
2017-09-10 17:25:29 +05:30
expect(SentNotification).to receive(:record).with(issue, any_args).exactly(9).times
2014-09-02 18:07:02 +05:30
notification.new_note(note)
2015-12-23 02:04:40 +05:30
should_email(@u_watcher)
should_email(note.noteable.author)
2017-08-17 22:00:37 +05:30
should_email(note.noteable.assignees.first)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_email(@subscribed_participant)
2017-09-10 17:25:29 +05:30
should_email(@u_custom_off)
2016-06-22 15:30:34 +05:30
should_not_email(@u_guest_custom)
2016-06-02 11:05:42 +05:30
should_not_email(@u_guest_watcher)
2015-12-23 02:04:40 +05:30
should_not_email(note.author)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@unsubscriber)
should_not_email(@u_outsider_mentioned)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
2017-08-17 22:00:37 +05:30
it "emails the note author if they've opted into notifications about their activity" do
add_users_with_subscription(note.project, issue)
reset_delivered_emails!
2017-09-10 17:25:29 +05:30
note.author.notified_of_own_activity = true
2017-08-17 22:00:37 +05:30
notification.new_note(note)
should_email(note.author)
end
2014-09-02 18:07:02 +05:30
it 'filters out "mentioned in" notes' do
2015-09-11 14:41:01 +05:30
mentioned_note = SystemNoteService.cross_reference(mentioned_issue, issue, issue.author)
2014-09-02 18:07:02 +05:30
2015-04-26 12:48:37 +05:30
expect(Notify).not_to receive(:note_issue_email)
2014-09-02 18:07:02 +05:30
notification.new_note(mentioned_note)
end
context 'participating' do
context 'by note' do
before do
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
note.author = @u_lazy_participant
note.save
notification.new_note(note)
end
it { should_not_email(@u_lazy_participant) }
end
end
2014-09-02 18:07:02 +05:30
end
describe 'new note on issue in project that belongs to a group' do
let(:group) { create(:group) }
before do
note.project.namespace_id = group.id
2015-04-26 12:48:37 +05:30
note.project.group.add_user(@u_watcher, GroupMember::MASTER)
2016-06-22 15:30:34 +05:30
note.project.group.add_user(@u_custom_global, GroupMember::MASTER)
2014-09-02 18:07:02 +05:30
note.project.save
2016-06-02 11:05:42 +05:30
@u_watcher.notification_settings_for(note.project).participating!
@u_watcher.notification_settings_for(note.project.group).global!
2016-06-22 15:30:34 +05:30
update_custom_notification(:new_note, @u_custom_global)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2014-09-02 18:07:02 +05:30
end
it do
notification.new_note(note)
2015-12-23 02:04:40 +05:30
should_email(note.noteable.author)
2017-08-17 22:00:37 +05:30
should_email(note.noteable.assignees.first)
2015-12-23 02:04:40 +05:30
should_email(@u_mentioned)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
should_not_email(@u_guest_custom)
2016-06-02 11:05:42 +05:30
should_not_email(@u_guest_watcher)
2015-12-23 02:04:40 +05:30
should_not_email(@u_watcher)
should_not_email(note.author)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2015-12-23 02:04:40 +05:30
end
2014-09-02 18:07:02 +05:30
end
end
2016-06-02 11:05:42 +05:30
context 'confidential issue note' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project, :public) }
2016-06-02 11:05:42 +05:30
let(:author) { create(:user) }
let(:assignee) { create(:user) }
let(:non_member) { create(:user) }
let(:member) { create(:user) }
let(:guest) { create(:user) }
2016-06-02 11:05:42 +05:30
let(:admin) { create(:admin) }
2017-08-17 22:00:37 +05:30
let(:confidential_issue) { create(:issue, :confidential, project: project, author: author, assignees: [assignee]) }
2016-06-02 11:05:42 +05:30
let(:note) { create(:note_on_issue, noteable: confidential_issue, project: project, note: "#{author.to_reference} #{assignee.to_reference} #{non_member.to_reference} #{member.to_reference} #{admin.to_reference}") }
2016-06-22 15:30:34 +05:30
let(:guest_watcher) { create_user_with_notification(:watch, "guest-watcher-confidential") }
2016-06-02 11:05:42 +05:30
it 'filters out users that can not read the issue' do
2017-08-17 22:00:37 +05:30
project.add_developer(member)
project.add_guest(guest)
2016-06-02 11:05:42 +05:30
expect(SentNotification).to receive(:record).with(confidential_issue, any_args).exactly(4).times
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2016-06-02 11:05:42 +05:30
notification.new_note(note)
should_not_email(non_member)
should_not_email(guest)
2016-06-22 15:30:34 +05:30
should_not_email(guest_watcher)
2016-06-02 11:05:42 +05:30
should_email(author)
should_email(assignee)
should_email(member)
should_email(admin)
end
end
2014-09-02 18:07:02 +05:30
context 'issue note mention' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project, :public) }
2017-08-17 22:00:37 +05:30
let(:issue) { create(:issue, project: project, assignees: [assignee]) }
let(:mentioned_issue) { create(:issue, assignees: issue.assignees) }
2014-09-02 18:07:02 +05:30
let(:note) { create(:note_on_issue, noteable: issue, project_id: issue.project_id, note: '@all mentioned') }
before do
build_team(note.project)
2017-08-17 22:00:37 +05:30
note.project.add_master(note.author)
reset_delivered_emails!
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#new_note' do
it 'notifies the team members' do
2015-12-23 02:04:40 +05:30
notification.new_note(note)
2014-09-02 18:07:02 +05:30
# Notify all team members
note.project.team.members.each do |member|
# User with disabled notification should not be notified
next if member.id == @u_disabled.id
# Author should not be notified
next if member.id == note.author.id
2018-03-17 18:26:18 +05:30
2015-12-23 02:04:40 +05:30
should_email(member)
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2015-12-23 02:04:40 +05:30
should_email(note.noteable.author)
2017-08-17 22:00:37 +05:30
should_email(note.noteable.assignees.first)
2015-12-23 02:04:40 +05:30
should_not_email(note.author)
should_email(@u_mentioned)
should_not_email(@u_disabled)
should_email(@u_not_mentioned)
2014-09-02 18:07:02 +05:30
end
it 'filters out "mentioned in" notes' do
2015-09-11 14:41:01 +05:30
mentioned_note = SystemNoteService.cross_reference(mentioned_issue, issue, issue.author)
2014-09-02 18:07:02 +05:30
2015-04-26 12:48:37 +05:30
expect(Notify).not_to receive(:note_issue_email)
2014-09-02 18:07:02 +05:30
notification.new_note(mentioned_note)
end
end
end
2016-06-02 11:05:42 +05:30
context 'project snippet note' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project, :public) }
2016-06-02 11:05:42 +05:30
let(:snippet) { create(:project_snippet, project: project, author: create(:user)) }
let(:note) { create(:note_on_project_snippet, noteable: snippet, project_id: snippet.project.id, note: '@all mentioned') }
before do
build_team(note.project)
2017-09-10 17:25:29 +05:30
# make sure these users can read the project snippet!
project.add_guest(@u_guest_watcher)
project.add_guest(@u_guest_custom)
2017-08-17 22:00:37 +05:30
note.project.add_master(note.author)
reset_delivered_emails!
2016-06-02 11:05:42 +05:30
end
describe '#new_note' do
it 'notifies the team members' do
notification.new_note(note)
# Notify all team members
note.project.team.members.each do |member|
# User with disabled notification should not be notified
next if member.id == @u_disabled.id
# Author should not be notified
next if member.id == note.author.id
2018-03-17 18:26:18 +05:30
2016-06-02 11:05:42 +05:30
should_email(member)
end
2016-06-22 15:30:34 +05:30
# it emails custom global users on mention
should_email(@u_custom_global)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
should_email(note.noteable.author)
should_not_email(note.author)
should_email(@u_mentioned)
should_not_email(@u_disabled)
should_email(@u_not_mentioned)
end
end
end
2017-08-17 22:00:37 +05:30
context 'personal snippet note' do
let(:snippet) { create(:personal_snippet, :public, author: @u_snippet_author) }
let(:note) { create(:note_on_personal_snippet, noteable: snippet, note: '@mentioned note', author: @u_note_author) }
before do
@u_watcher = create_global_setting_for(create(:user), :watch)
@u_participant = create_global_setting_for(create(:user), :participating)
@u_disabled = create_global_setting_for(create(:user), :disabled)
@u_mentioned = create_global_setting_for(create(:user, username: 'mentioned'), :mention)
@u_mentioned_level = create_global_setting_for(create(:user, username: 'participator'), :mention)
@u_note_author = create(:user, username: 'note_author')
@u_snippet_author = create(:user, username: 'snippet_author')
@u_not_mentioned = create_global_setting_for(create(:user, username: 'regular'), :participating)
reset_delivered_emails!
end
let!(:notes) do
[
create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_watcher),
create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_participant),
create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_mentioned),
create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_disabled),
2017-09-10 17:25:29 +05:30
create(:note_on_personal_snippet, noteable: snippet, note: 'note', author: @u_note_author)
2017-08-17 22:00:37 +05:30
]
end
describe '#new_note' do
it 'notifies the participants' do
notification.new_note(note)
# it emails participants
should_email(@u_watcher)
should_email(@u_participant)
should_email(@u_watcher)
should_email(@u_snippet_author)
# it emails mentioned users
should_email(@u_mentioned)
# it does not email participants with mention notification level
should_not_email(@u_mentioned_level)
# it does not email note author
should_not_email(@u_note_author)
end
end
end
2014-09-02 18:07:02 +05:30
context 'commit note' do
2017-08-17 22:00:37 +05:30
let(:project) { create(:project, :public, :repository) }
2015-09-11 14:41:01 +05:30
let(:note) { create(:note_on_commit, project: project) }
2014-09-02 18:07:02 +05:30
before do
build_team(note.project)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2017-09-10 17:25:29 +05:30
allow(note.noteable).to receive(:author).and_return(@u_committer)
2017-08-17 22:00:37 +05:30
update_custom_notification(:new_note, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:new_note, @u_custom_global)
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#new_note, #perform_enqueued_jobs' do
2014-09-02 18:07:02 +05:30
it do
notification.new_note(note)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
should_email(@u_guest_custom)
2015-12-23 02:04:40 +05:30
should_email(@u_committer)
should_email(@u_watcher)
should_not_email(@u_mentioned)
should_not_email(note.author)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
it do
note.update_attribute(:note, '@mention referenced')
notification.new_note(note)
2015-12-23 02:04:40 +05:30
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2015-12-23 02:04:40 +05:30
should_email(@u_committer)
should_email(@u_watcher)
should_email(@u_mentioned)
should_not_email(note.author)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
it do
@u_committer = create_global_setting_for(@u_committer, :mention)
2015-04-26 12:48:37 +05:30
notification.new_note(note)
2015-12-23 02:04:40 +05:30
should_not_email(@u_committer)
2014-09-02 18:07:02 +05:30
end
end
end
2016-08-24 12:49:21 +05:30
context "merge request diff note" do
2017-08-17 22:00:37 +05:30
let(:project) { create(:project, :repository) }
2016-08-24 12:49:21 +05:30
let(:user) { create(:user) }
2018-03-17 18:26:18 +05:30
let(:merge_request) { create(:merge_request, source_project: project, assignee: user, author: create(:user)) }
2016-08-24 12:49:21 +05:30
let(:note) { create(:diff_note_on_merge_request, project: project, noteable: merge_request) }
before do
build_team(note.project)
2017-08-17 22:00:37 +05:30
project.add_master(merge_request.author)
project.add_master(merge_request.assignee)
2016-08-24 12:49:21 +05:30
end
describe '#new_note' do
it "records sent notifications" do
2018-03-17 18:26:18 +05:30
# 3 SentNotification are sent: the MR assignee and author, and the @u_watcher
2016-11-03 12:29:30 +05:30
expect(SentNotification).to receive(:record_note).with(note, any_args).exactly(3).times.and_call_original
2016-08-24 12:49:21 +05:30
notification.new_note(note)
2018-03-17 18:26:18 +05:30
expect(SentNotification.last(3).map(&:recipient).map(&:id))
.to contain_exactly(merge_request.assignee.id, merge_request.author.id, @u_watcher.id)
2017-08-17 22:00:37 +05:30
expect(SentNotification.last.in_reply_to_discussion_id).to eq(note.discussion_id)
2016-08-24 12:49:21 +05:30
end
end
end
2014-09-02 18:07:02 +05:30
end
describe 'Issues' do
2017-08-17 22:00:37 +05:30
let(:group) { create(:group) }
2017-09-10 17:25:29 +05:30
let(:project) { create(:project, :public, namespace: group) }
let(:another_project) { create(:project, :public, namespace: group) }
2017-08-17 22:00:37 +05:30
let(:issue) { create :issue, project: project, assignees: [assignee], description: 'cc @participant' }
2014-09-02 18:07:02 +05:30
before do
build_team(issue.project)
2017-08-17 22:00:37 +05:30
build_group(issue.project)
2015-04-26 12:48:37 +05:30
add_users_with_subscription(issue.project, issue)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
update_custom_notification(:new_issue, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:new_issue, @u_custom_global)
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#new_issue' do
2014-09-02 18:07:02 +05:30
it do
notification.new_issue(issue, @u_disabled)
2015-12-23 02:04:40 +05:30
2017-08-17 22:00:37 +05:30
should_email(assignee)
2015-12-23 02:04:40 +05:30
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
2017-08-17 22:00:37 +05:30
should_email(@g_global_watcher)
should_email(@g_watcher)
2015-12-23 02:04:40 +05:30
should_not_email(@u_mentioned)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
it do
2017-08-17 22:00:37 +05:30
create_global_setting_for(issue.assignees.first, :mention)
2015-04-26 12:48:37 +05:30
notification.new_issue(issue, @u_disabled)
2014-09-02 18:07:02 +05:30
2017-08-17 22:00:37 +05:30
should_not_email(issue.assignees.first)
end
2018-03-17 18:26:18 +05:30
it 'properly prioritizes notification reason' do
# have assignee be both assigned and mentioned
issue.update_attribute(:description, "/cc #{assignee.to_reference} #{@u_mentioned.to_reference}")
notification.new_issue(issue, @u_disabled)
email = find_email_for(assignee)
expect(email).to have_header('X-GitLab-NotificationReason', 'assigned')
email = find_email_for(@u_mentioned)
expect(email).to have_header('X-GitLab-NotificationReason', 'mentioned')
end
it 'adds "assigned" reason for assignees if any' do
notification.new_issue(issue, @u_disabled)
email = find_email_for(assignee)
expect(email).to have_header('X-GitLab-NotificationReason', 'assigned')
end
it "emails any mentioned users with the mention level" do
issue.description = @u_mentioned.to_reference
notification.new_issue(issue, @u_disabled)
email = find_email_for(@u_mentioned)
expect(email).not_to be_nil
expect(email).to have_header('X-GitLab-NotificationReason', 'mentioned')
end
2017-08-17 22:00:37 +05:30
it "emails the author if they've opted into notifications about their activity" do
issue.author.notified_of_own_activity = true
notification.new_issue(issue, issue.author)
should_email(issue.author)
end
it "doesn't email the author if they haven't opted into notifications about their activity" do
notification.new_issue(issue, issue.author)
should_not_email(issue.author)
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
it "emails subscribers of the issue's labels" do
2017-08-17 22:00:37 +05:30
user_1 = create(:user)
user_2 = create(:user)
user_3 = create(:user)
user_4 = create(:user)
label = create(:label, project: project, issues: [issue])
group_label = create(:group_label, group: group, issues: [issue])
2016-09-29 09:46:39 +05:30
issue.reload
2017-08-17 22:00:37 +05:30
label.toggle_subscription(user_1, project)
group_label.toggle_subscription(user_2, project)
group_label.toggle_subscription(user_3, another_project)
group_label.toggle_subscription(user_4)
2016-06-02 11:05:42 +05:30
notification.new_issue(issue, @u_disabled)
2017-08-17 22:00:37 +05:30
should_email(user_1)
should_email(user_2)
should_not_email(user_3)
should_email(user_4)
2016-06-02 11:05:42 +05:30
end
context 'confidential issues' do
let(:author) { create(:user) }
let(:assignee) { create(:user) }
let(:non_member) { create(:user) }
let(:member) { create(:user) }
let(:guest) { create(:user) }
2016-06-02 11:05:42 +05:30
let(:admin) { create(:admin) }
2017-08-17 22:00:37 +05:30
let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }
2016-06-02 11:05:42 +05:30
it "emails subscribers of the issue's labels that can read the issue" do
2017-08-17 22:00:37 +05:30
project.add_developer(member)
project.add_guest(guest)
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
label = create(:label, project: project, issues: [confidential_issue])
2016-09-29 09:46:39 +05:30
confidential_issue.reload
2017-08-17 22:00:37 +05:30
label.toggle_subscription(non_member, project)
label.toggle_subscription(author, project)
label.toggle_subscription(assignee, project)
label.toggle_subscription(member, project)
label.toggle_subscription(guest, project)
label.toggle_subscription(admin, project)
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2016-06-02 11:05:42 +05:30
notification.new_issue(confidential_issue, @u_disabled)
2016-06-22 15:30:34 +05:30
should_not_email(@u_guest_watcher)
2016-06-02 11:05:42 +05:30
should_not_email(non_member)
should_not_email(author)
should_not_email(guest)
2016-06-02 11:05:42 +05:30
should_email(assignee)
should_email(member)
should_email(admin)
end
end
2014-09-02 18:07:02 +05:30
end
2016-09-13 17:45:13 +05:30
describe '#new_mentions_in_issue' do
let(:notification_method) { :new_mentions_in_issue }
let(:mentionable) { issue }
include_examples 'notifications for new mentions'
end
2016-06-02 11:05:42 +05:30
describe '#reassigned_issue' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:reassign_issue, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:reassign_issue, @u_custom_global)
end
2016-01-29 22:53:50 +05:30
it 'emails new assignee' do
2017-08-17 22:00:37 +05:30
notification.reassigned_issue(issue, @u_disabled, [assignee])
2014-09-02 18:07:02 +05:30
2017-08-17 22:00:37 +05:30
should_email(issue.assignees.first)
2015-12-23 02:04:40 +05:30
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
2016-01-29 22:53:50 +05:30
2018-03-17 18:26:18 +05:30
it 'adds "assigned" reason for new assignee' do
notification.reassigned_issue(issue, @u_disabled, [assignee])
email = find_email_for(assignee)
expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
end
2016-01-29 22:53:50 +05:30
it 'emails previous assignee even if he has the "on mention" notif level' do
2017-08-17 22:00:37 +05:30
issue.assignees = [@u_mentioned]
notification.reassigned_issue(issue, @u_disabled, [@u_watcher])
2016-01-29 22:53:50 +05:30
should_email(@u_mentioned)
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
2016-01-29 22:53:50 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2016-01-29 22:53:50 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2016-01-29 22:53:50 +05:30
end
it 'emails new assignee even if he has the "on mention" notif level' do
2017-08-17 22:00:37 +05:30
issue.assignees = [@u_mentioned]
notification.reassigned_issue(issue, @u_disabled, [@u_mentioned])
2016-01-29 22:53:50 +05:30
2017-08-17 22:00:37 +05:30
expect(issue.assignees.first).to be @u_mentioned
should_email(issue.assignees.first)
2016-01-29 22:53:50 +05:30
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
2016-01-29 22:53:50 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2016-01-29 22:53:50 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2016-01-29 22:53:50 +05:30
end
it 'emails new assignee' do
2017-08-17 22:00:37 +05:30
issue.assignees = [@u_mentioned]
notification.reassigned_issue(issue, @u_disabled, [@u_mentioned])
2016-01-29 22:53:50 +05:30
2017-08-17 22:00:37 +05:30
expect(issue.assignees.first).to be @u_mentioned
should_email(issue.assignees.first)
2016-01-29 22:53:50 +05:30
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
2016-01-29 22:53:50 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2016-01-29 22:53:50 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2016-01-29 22:53:50 +05:30
end
it 'does not email new assignee if they are the current user' do
2017-08-17 22:00:37 +05:30
issue.assignees = [@u_mentioned]
notification.reassigned_issue(issue, @u_mentioned, [@u_mentioned])
2016-01-29 22:53:50 +05:30
2017-08-17 22:00:37 +05:30
expect(issue.assignees.first).to be @u_mentioned
2016-01-29 22:53:50 +05:30
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
2016-01-29 22:53:50 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2017-08-17 22:00:37 +05:30
should_not_email(issue.assignees.first)
2016-01-29 22:53:50 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { issue }
let(:notification_trigger) { notification.reassigned_issue(issue, @u_disabled, [assignee]) }
2016-01-29 22:53:50 +05:30
end
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#relabeled_issue' do
2017-08-17 22:00:37 +05:30
let(:group_label_1) { create(:group_label, group: group, title: 'Group Label 1', issues: [issue]) }
let(:group_label_2) { create(:group_label, group: group, title: 'Group Label 2') }
let(:label_1) { create(:label, project: project, title: 'Label 1', issues: [issue]) }
let(:label_2) { create(:label, project: project, title: 'Label 2') }
let!(:subscriber_to_group_label_1) { create(:user) { |u| group_label_1.toggle_subscription(u, project) } }
let!(:subscriber_1_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u, project) } }
let!(:subscriber_2_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u) } }
let!(:subscriber_to_group_label_2_on_another_project) { create(:user) { |u| group_label_2.toggle_subscription(u, another_project) } }
let!(:subscriber_to_label_1) { create(:user) { |u| label_1.toggle_subscription(u, project) } }
let!(:subscriber_to_label_2) { create(:user) { |u| label_2.toggle_subscription(u, project) } }
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
it "emails the current user if they've opted into notifications about their activity" do
subscriber_to_label_2.notified_of_own_activity = true
notification.relabeled_issue(issue, [group_label_2, label_2], subscriber_to_label_2)
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
should_email(subscriber_to_label_2)
end
it "doesn't email the current user if they haven't opted into notifications about their activity" do
notification.relabeled_issue(issue, [group_label_2, label_2], subscriber_to_label_2)
should_not_email(subscriber_to_label_2)
2016-06-02 11:05:42 +05:30
end
it "doesn't send email to anyone but subscribers of the given labels" do
2017-08-17 22:00:37 +05:30
notification.relabeled_issue(issue, [group_label_2, label_2], @u_disabled)
2016-06-02 11:05:42 +05:30
2017-09-10 17:25:29 +05:30
should_not_email(subscriber_to_label_1)
should_not_email(subscriber_to_group_label_1)
should_not_email(subscriber_to_group_label_2_on_another_project)
should_email(subscriber_1_to_group_label_2)
should_email(subscriber_2_to_group_label_2)
should_email(subscriber_to_label_2)
2017-08-17 22:00:37 +05:30
should_not_email(issue.assignees.first)
2016-06-02 11:05:42 +05:30
should_not_email(issue.author)
should_not_email(@u_watcher)
should_not_email(@u_guest_watcher)
should_not_email(@u_participant_mentioned)
should_not_email(@subscriber)
should_not_email(@watcher_and_subscriber)
should_not_email(@unsubscriber)
should_not_email(@u_participating)
end
2018-03-17 18:26:18 +05:30
it "doesn't send multiple email when a user is subscribed to multiple given labels" do
subscriber_to_both = create(:user) do |user|
[label_1, label_2].each { |label| label.toggle_subscription(user, project) }
end
notification.relabeled_issue(issue, [label_1, label_2], @u_disabled)
should_email(subscriber_to_label_1)
should_email(subscriber_to_label_2)
should_email(subscriber_to_both)
end
2016-06-02 11:05:42 +05:30
context 'confidential issues' do
let(:author) { create(:user) }
let(:assignee) { create(:user) }
let(:non_member) { create(:user) }
let(:member) { create(:user) }
let(:guest) { create(:user) }
2016-06-02 11:05:42 +05:30
let(:admin) { create(:admin) }
2017-08-17 22:00:37 +05:30
let(:confidential_issue) { create(:issue, :confidential, project: project, title: 'Confidential issue', author: author, assignees: [assignee]) }
let!(:label_1) { create(:label, project: project, issues: [confidential_issue]) }
let!(:label_2) { create(:label, project: project) }
2016-06-02 11:05:42 +05:30
it "emails subscribers of the issue's labels that can read the issue" do
2017-08-17 22:00:37 +05:30
project.add_developer(member)
project.add_guest(guest)
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
label_2.toggle_subscription(non_member, project)
label_2.toggle_subscription(author, project)
label_2.toggle_subscription(assignee, project)
label_2.toggle_subscription(member, project)
label_2.toggle_subscription(guest, project)
label_2.toggle_subscription(admin, project)
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2016-06-02 11:05:42 +05:30
notification.relabeled_issue(confidential_issue, [label_2], @u_disabled)
should_not_email(non_member)
should_not_email(guest)
2016-06-02 11:05:42 +05:30
should_email(author)
should_email(assignee)
should_email(member)
should_email(admin)
end
end
end
describe '#close_issue' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:close_issue, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:close_issue, @u_custom_global)
end
2016-09-13 17:45:13 +05:30
it 'sends email to issue assignee and issue author' do
2014-09-02 18:07:02 +05:30
notification.close_issue(issue, @u_disabled)
2017-08-17 22:00:37 +05:30
should_email(issue.assignees.first)
2015-12-23 02:04:40 +05:30
should_email(issue.author)
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { issue }
let(:notification_trigger) { notification.close_issue(issue, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
2016-06-02 11:05:42 +05:30
describe '#reopen_issue' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:reopen_issue, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:reopen_issue, @u_custom_global)
end
2017-08-17 22:00:37 +05:30
it 'sends email to issue notification recipients' do
2014-09-02 18:07:02 +05:30
notification.reopen_issue(issue, @u_disabled)
2017-08-17 22:00:37 +05:30
should_email(issue.assignees.first)
2015-12-23 02:04:40 +05:30
should_email(issue.author)
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
2017-08-17 22:00:37 +05:30
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { issue }
let(:notification_trigger) { notification.reopen_issue(issue, @u_disabled) }
end
end
2017-08-17 22:00:37 +05:30
describe '#issue_moved' do
let(:new_issue) { create(:issue) }
2017-08-17 22:00:37 +05:30
it 'sends email to issue notification recipients' do
notification.issue_moved(issue, new_issue, @u_disabled)
2017-08-17 22:00:37 +05:30
should_email(issue.assignees.first)
should_email(issue.author)
should_email(@u_watcher)
should_email(@u_guest_watcher)
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { issue }
let(:notification_trigger) { notification.issue_moved(issue, new_issue, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
end
describe 'Merge Requests' do
2017-08-17 22:00:37 +05:30
let(:group) { create(:group) }
let(:project) { create(:project, :public, :repository, namespace: group) }
2017-09-10 17:25:29 +05:30
let(:another_project) { create(:project, :public, namespace: group) }
2015-09-11 14:41:01 +05:30
let(:merge_request) { create :merge_request, source_project: project, assignee: create(:user), description: 'cc @participant' }
2014-09-02 18:07:02 +05:30
before do
build_team(merge_request.target_project)
2015-04-26 12:48:37 +05:30
add_users_with_subscription(merge_request.target_project, merge_request)
2017-08-17 22:00:37 +05:30
update_custom_notification(:new_merge_request, @u_guest_custom, resource: project)
2016-09-13 17:45:13 +05:30
update_custom_notification(:new_merge_request, @u_custom_global)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#new_merge_request' do
2014-09-02 18:07:02 +05:30
it do
notification.new_merge_request(merge_request, @u_disabled)
2015-12-23 02:04:40 +05:30
should_email(merge_request.assignee)
should_email(@u_watcher)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
2018-03-17 18:26:18 +05:30
it 'adds "assigned" reason for assignee, if any' do
notification.new_merge_request(merge_request, @u_disabled)
email = find_email_for(merge_request.assignee)
expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
end
it "emails any mentioned users with the mention level" do
merge_request.description = @u_mentioned.to_reference
notification.new_merge_request(merge_request, @u_disabled)
should_email(@u_mentioned)
end
2017-08-17 22:00:37 +05:30
it "emails the author if they've opted into notifications about their activity" do
merge_request.author.notified_of_own_activity = true
notification.new_merge_request(merge_request, merge_request.author)
should_email(merge_request.author)
2018-03-17 18:26:18 +05:30
email = find_email_for(merge_request.author)
expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::OWN_ACTIVITY)
2017-08-17 22:00:37 +05:30
end
it "doesn't email the author if they haven't opted into notifications about their activity" do
notification.new_merge_request(merge_request, merge_request.author)
should_not_email(merge_request.author)
end
2016-06-02 11:05:42 +05:30
it "emails subscribers of the merge request's labels" do
2017-08-17 22:00:37 +05:30
user_1 = create(:user)
user_2 = create(:user)
user_3 = create(:user)
user_4 = create(:user)
label = create(:label, project: project, merge_requests: [merge_request])
group_label = create(:group_label, group: group, merge_requests: [merge_request])
label.toggle_subscription(user_1, project)
group_label.toggle_subscription(user_2, project)
group_label.toggle_subscription(user_3, another_project)
group_label.toggle_subscription(user_4)
2016-06-02 11:05:42 +05:30
notification.new_merge_request(merge_request, @u_disabled)
2017-08-17 22:00:37 +05:30
should_email(user_1)
should_email(user_2)
should_not_email(user_3)
should_email(user_4)
2016-06-02 11:05:42 +05:30
end
context 'participating' do
2017-08-17 22:00:37 +05:30
it_should_behave_like 'participating by assignee notification' do
let(:participant) { create(:user, username: 'user-participant')}
let(:issuable) { merge_request }
let(:notification_trigger) { notification.new_merge_request(merge_request, @u_disabled) }
end
2017-08-17 22:00:37 +05:30
it_should_behave_like 'participating by note notification' do
let(:participant) { create(:user, username: 'user-participant')}
let(:issuable) { merge_request }
let(:notification_trigger) { notification.new_merge_request(merge_request, @u_disabled) }
end
context 'by author' do
2017-08-17 22:00:37 +05:30
let(:participant) { create(:user, username: 'user-participant')}
before do
2017-08-17 22:00:37 +05:30
merge_request.author = participant
merge_request.save
notification.new_merge_request(merge_request, @u_disabled)
end
2017-08-17 22:00:37 +05:30
it { should_not_email(participant) }
end
end
2014-09-02 18:07:02 +05:30
end
2016-09-13 17:45:13 +05:30
describe '#new_mentions_in_merge_request' do
let(:notification_method) { :new_mentions_in_merge_request }
let(:mentionable) { merge_request }
include_examples 'notifications for new mentions'
end
2016-06-02 11:05:42 +05:30
describe '#reassigned_merge_request' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:reassign_merge_request, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:reassign_merge_request, @u_custom_global)
end
2014-09-02 18:07:02 +05:30
it do
notification.reassigned_merge_request(merge_request, merge_request.author)
2015-12-23 02:04:40 +05:30
should_email(merge_request.assignee)
should_email(@u_watcher)
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2018-03-17 18:26:18 +05:30
it 'adds "assigned" reason for new assignee' do
notification.reassigned_merge_request(merge_request, merge_request.author)
email = find_email_for(merge_request.assignee)
expect(email).to have_header('X-GitLab-NotificationReason', NotificationReason::ASSIGNED)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { merge_request }
let(:notification_trigger) { notification.reassigned_merge_request(merge_request, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
2016-06-02 11:05:42 +05:30
describe '#relabel_merge_request' do
2017-08-17 22:00:37 +05:30
let(:group_label_1) { create(:group_label, group: group, title: 'Group Label 1', merge_requests: [merge_request]) }
let(:group_label_2) { create(:group_label, group: group, title: 'Group Label 2') }
let(:label_1) { create(:label, project: project, title: 'Label 1', merge_requests: [merge_request]) }
let(:label_2) { create(:label, project: project, title: 'Label 2') }
let!(:subscriber_to_group_label_1) { create(:user) { |u| group_label_1.toggle_subscription(u, project) } }
let!(:subscriber_1_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u, project) } }
let!(:subscriber_2_to_group_label_2) { create(:user) { |u| group_label_2.toggle_subscription(u) } }
let!(:subscriber_to_group_label_2_on_another_project) { create(:user) { |u| group_label_2.toggle_subscription(u, another_project) } }
let!(:subscriber_to_label_1) { create(:user) { |u| label_1.toggle_subscription(u, project) } }
let!(:subscriber_to_label_2) { create(:user) { |u| label_2.toggle_subscription(u, project) } }
2016-06-02 11:05:42 +05:30
2017-09-10 17:25:29 +05:30
it "doesn't send email to anyone but subscribers of the given labels" do
2017-08-17 22:00:37 +05:30
notification.relabeled_merge_request(merge_request, [group_label_2, label_2], @u_disabled)
should_not_email(subscriber_to_label_1)
should_not_email(subscriber_to_group_label_1)
should_not_email(subscriber_to_group_label_2_on_another_project)
should_email(subscriber_1_to_group_label_2)
should_email(subscriber_2_to_group_label_2)
should_email(subscriber_to_label_2)
2016-06-02 11:05:42 +05:30
should_not_email(merge_request.assignee)
should_not_email(merge_request.author)
should_not_email(@u_watcher)
should_not_email(@u_participant_mentioned)
should_not_email(@subscriber)
should_not_email(@watcher_and_subscriber)
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_lazy_participant)
2016-06-02 11:05:42 +05:30
end
end
describe '#closed_merge_request' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:close_merge_request, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:close_merge_request, @u_custom_global)
end
2014-09-02 18:07:02 +05:30
it do
notification.close_mr(merge_request, @u_disabled)
2015-12-23 02:04:40 +05:30
should_email(merge_request.assignee)
should_email(@u_watcher)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { merge_request }
let(:notification_trigger) { notification.close_mr(merge_request, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
2016-06-02 11:05:42 +05:30
describe '#merged_merge_request' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:merge_merge_request, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:merge_merge_request, @u_custom_global)
end
2014-09-02 18:07:02 +05:30
it do
notification.merge_mr(merge_request, @u_disabled)
2015-12-23 02:04:40 +05:30
should_email(merge_request.assignee)
should_email(@u_watcher)
2017-09-10 17:25:29 +05:30
should_email(@u_guest_watcher)
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it "notifies the merger when the pipeline succeeds is true" do
merge_request.merge_when_pipeline_succeeds = true
2016-11-03 12:29:30 +05:30
notification.merge_mr(merge_request, @u_watcher)
should_email(@u_watcher)
end
2017-08-17 22:00:37 +05:30
it "does not notify the merger when the pipeline succeeds is false" do
merge_request.merge_when_pipeline_succeeds = false
2016-11-03 12:29:30 +05:30
notification.merge_mr(merge_request, @u_watcher)
should_not_email(@u_watcher)
end
2017-08-17 22:00:37 +05:30
it "notifies the merger when the pipeline succeeds is false but they've opted into notifications about their activity" do
merge_request.merge_when_pipeline_succeeds = false
@u_watcher.notified_of_own_activity = true
notification.merge_mr(merge_request, @u_watcher)
2017-08-17 22:00:37 +05:30
should_email(@u_watcher)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { merge_request }
let(:notification_trigger) { notification.merge_mr(merge_request, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
2016-06-02 11:05:42 +05:30
describe '#reopen_merge_request' do
2016-06-22 15:30:34 +05:30
before do
2017-08-17 22:00:37 +05:30
update_custom_notification(:reopen_merge_request, @u_guest_custom, resource: project)
2016-06-22 15:30:34 +05:30
update_custom_notification(:reopen_merge_request, @u_custom_global)
end
2014-09-02 18:07:02 +05:30
it do
notification.reopen_mr(merge_request, @u_disabled)
2015-12-23 02:04:40 +05:30
should_email(merge_request.assignee)
should_email(@u_watcher)
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
2016-06-02 11:05:42 +05:30
should_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_email(@u_guest_custom)
should_email(@u_custom_global)
2015-12-23 02:04:40 +05:30
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { merge_request }
let(:notification_trigger) { notification.reopen_mr(merge_request, @u_disabled) }
2014-09-02 18:07:02 +05:30
end
end
2016-09-13 17:45:13 +05:30
describe "#resolve_all_discussions" do
it do
notification.resolve_all_discussions(merge_request, @u_disabled)
should_email(merge_request.assignee)
should_email(@u_watcher)
should_email(@u_participant_mentioned)
should_email(@subscriber)
should_email(@watcher_and_subscriber)
should_email(@u_guest_watcher)
should_not_email(@unsubscriber)
should_not_email(@u_participating)
should_not_email(@u_disabled)
should_not_email(@u_lazy_participant)
end
2017-08-17 22:00:37 +05:30
it_behaves_like 'participating notifications' do
let(:participant) { create(:user, username: 'user-participant') }
let(:issuable) { merge_request }
let(:notification_trigger) { notification.resolve_all_discussions(merge_request, @u_disabled) }
2016-09-13 17:45:13 +05:30
end
end
2014-09-02 18:07:02 +05:30
end
describe 'Projects' do
2017-09-10 17:25:29 +05:30
let(:project) { create(:project) }
2014-09-02 18:07:02 +05:30
before do
build_team(project)
2017-08-17 22:00:37 +05:30
reset_delivered_emails!
2014-09-02 18:07:02 +05:30
end
2016-06-02 11:05:42 +05:30
describe '#project_was_moved' do
2014-09-02 18:07:02 +05:30
it do
2015-10-24 18:46:33 +05:30
notification.project_was_moved(project, "gitlab/gitlab")
2014-09-02 18:07:02 +05:30
2015-12-23 02:04:40 +05:30
should_email(@u_watcher)
should_email(@u_participating)
should_email(@u_lazy_participant)
2016-06-22 15:30:34 +05:30
should_email(@u_custom_global)
2016-06-02 11:05:42 +05:30
should_not_email(@u_guest_watcher)
2016-06-22 15:30:34 +05:30
should_not_email(@u_guest_custom)
2015-12-23 02:04:40 +05:30
should_not_email(@u_disabled)
2014-09-02 18:07:02 +05:30
end
end
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
context 'user with notifications disabled' do
describe '#project_exported' do
it do
notification.project_exported(project, @u_disabled)
should_not_email_anyone
end
end
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
describe '#project_not_exported' do
it do
notification.project_not_exported(project, @u_disabled, ['error'])
should_not_email_anyone
end
2017-08-17 22:00:37 +05:30
end
end
2018-03-17 18:26:18 +05:30
context 'user with notifications enabled' do
describe '#project_exported' do
it do
notification.project_exported(project, @u_participating)
2017-08-17 22:00:37 +05:30
2018-03-17 18:26:18 +05:30
should_only_email(@u_participating)
end
end
describe '#project_not_exported' do
it do
notification.project_not_exported(project, @u_participating, ['error'])
should_only_email(@u_participating)
end
2017-08-17 22:00:37 +05:30
end
end
2014-09-02 18:07:02 +05:30
end
2016-09-13 17:45:13 +05:30
describe 'GroupMember' do
2018-03-27 19:54:05 +05:30
let(:added_user) { create(:user) }
describe '#new_access_request' do
let(:master) { create(:user) }
let(:owner) { create(:user) }
let(:developer) { create(:user) }
let!(:group) do
create(:group, :public, :access_requestable) do |group|
group.add_owner(owner)
group.add_master(master)
group.add_developer(developer)
end
end
before do
reset_delivered_emails!
end
it 'sends notification to group owners_and_masters' do
group.request_access(added_user)
should_email(owner)
should_email(master)
should_not_email(developer)
end
end
2016-09-13 17:45:13 +05:30
describe '#decline_group_invite' do
let(:creator) { create(:user) }
let(:group) { create(:group) }
let(:member) { create(:user) }
2018-03-17 18:26:18 +05:30
before do
2016-09-13 17:45:13 +05:30
group.add_owner(creator)
group.add_developer(member, creator)
end
it do
2018-03-17 18:26:18 +05:30
group_member = group.members.last
2016-09-13 17:45:13 +05:30
expect do
notification.decline_group_invite(group_member)
end.to change { ActionMailer::Base.deliveries.size }.by(1)
end
end
2018-03-17 18:26:18 +05:30
describe '#new_group_member' do
let(:group) { create(:group) }
it 'sends a notification' do
2018-03-27 19:54:05 +05:30
group.add_guest(added_user)
2018-03-17 18:26:18 +05:30
should_only_email(added_user)
end
describe 'when notifications are disabled' do
before do
create_global_setting_for(added_user, :disabled)
end
it 'does not send a notification' do
2018-03-27 19:54:05 +05:30
group.add_guest(added_user)
2018-03-17 18:26:18 +05:30
should_not_email_anyone
end
end
end
2016-09-13 17:45:13 +05:30
end
describe 'ProjectMember' do
2018-03-27 19:54:05 +05:30
let(:project) { create(:project) }
set(:added_user) { create(:user) }
describe '#new_access_request' do
context 'for a project in a user namespace' do
let(:project) do
create(:project, :public, :access_requestable) do |project|
project.add_master(project.owner)
end
end
it 'sends notification to project owners_and_masters' do
project.request_access(added_user)
should_only_email(project.owner)
end
end
context 'for a project in a group' do
let(:group_owner) { create(:user) }
let(:group) { create(:group).tap { |g| g.add_owner(group_owner) } }
let!(:project) { create(:project, :public, :access_requestable, namespace: group) }
before do
reset_delivered_emails!
end
it 'sends notification to group owners_and_masters' do
project.request_access(added_user)
should_only_email(group_owner)
end
end
end
2016-09-13 17:45:13 +05:30
describe '#decline_group_invite' do
let(:member) { create(:user) }
2018-03-17 18:26:18 +05:30
before do
2017-08-17 22:00:37 +05:30
project.add_developer(member, current_user: project.owner)
2016-09-13 17:45:13 +05:30
end
it do
2018-03-17 18:26:18 +05:30
project_member = project.members.last
2016-09-13 17:45:13 +05:30
expect do
notification.decline_project_invite(project_member)
end.to change { ActionMailer::Base.deliveries.size }.by(1)
end
end
2018-03-17 18:26:18 +05:30
describe '#new_project_member' do
it do
create_member!
should_only_email(added_user)
end
2018-03-27 19:54:05 +05:30
context 'when notifications are disabled' do
2018-03-17 18:26:18 +05:30
before do
create_global_setting_for(added_user, :disabled)
end
it do
create_member!
should_not_email_anyone
end
end
end
2018-03-27 19:54:05 +05:30
def create_member!
create(:project_member, user: added_user, project: project)
end
2016-09-13 17:45:13 +05:30
end
2016-11-03 12:29:30 +05:30
context 'guest user in private project' do
2017-09-10 17:25:29 +05:30
let(:private_project) { create(:project, :private) }
2016-11-03 12:29:30 +05:30
let(:guest) { create(:user) }
let(:developer) { create(:user) }
let(:assignee) { create(:user) }
let(:merge_request) { create(:merge_request, source_project: private_project, assignee: assignee) }
let(:merge_request1) { create(:merge_request, source_project: private_project, assignee: assignee, description: "cc @#{guest.username}") }
let(:note) { create(:note, noteable: merge_request, project: private_project) }
before do
2017-08-17 22:00:37 +05:30
private_project.add_developer(assignee)
private_project.add_developer(developer)
private_project.add_guest(guest)
2016-11-03 12:29:30 +05:30
ActionMailer::Base.deliveries.clear
end
it 'filters out guests when new note is created' do
expect(SentNotification).to receive(:record).with(merge_request, any_args).exactly(1).times
notification.new_note(note)
should_not_email(guest)
should_email(assignee)
end
it 'filters out guests when new merge request is created' do
notification.new_merge_request(merge_request1, @u_disabled)
should_not_email(guest)
should_email(assignee)
end
it 'filters out guests when merge request is closed' do
notification.close_mr(merge_request, developer)
should_not_email(guest)
should_email(assignee)
end
it 'filters out guests when merge request is reopened' do
notification.reopen_mr(merge_request, developer)
should_not_email(guest)
should_email(assignee)
end
it 'filters out guests when merge request is merged' do
notification.merge_mr(merge_request, developer)
should_not_email(guest)
should_email(assignee)
end
end
2017-08-17 22:00:37 +05:30
describe 'Pipelines' do
describe '#pipeline_finished' do
let(:project) { create(:project, :public, :repository) }
let(:u_member) { create(:user) }
let(:u_watcher) { create_user_with_notification(:watch, 'watcher') }
let(:u_custom_notification_unset) do
create_user_with_notification(:custom, 'custom_unset')
end
let(:u_custom_notification_enabled) do
user = create_user_with_notification(:custom, 'custom_enabled')
update_custom_notification(:success_pipeline, user, resource: project)
update_custom_notification(:failed_pipeline, user, resource: project)
user
end
let(:u_custom_notification_disabled) do
user = create_user_with_notification(:custom, 'custom_disabled')
update_custom_notification(:success_pipeline, user, resource: project, value: false)
update_custom_notification(:failed_pipeline, user, resource: project, value: false)
user
end
let(:commit) { project.commit }
def create_pipeline(user, status)
create(:ci_pipeline, status,
project: project,
user: user,
ref: 'refs/heads/master',
sha: commit.id,
before_sha: '00000000')
end
before do
project.add_master(u_member)
project.add_master(u_watcher)
project.add_master(u_custom_notification_unset)
project.add_master(u_custom_notification_enabled)
project.add_master(u_custom_notification_disabled)
reset_delivered_emails!
end
context 'with a successful pipeline' do
context 'when the creator has default settings' do
before do
pipeline = create_pipeline(u_member, :success)
notification.pipeline_finished(pipeline)
end
it 'notifies nobody' do
should_not_email_anyone
end
end
context 'when the creator has watch set' do
before do
pipeline = create_pipeline(u_watcher, :success)
notification.pipeline_finished(pipeline)
end
it 'notifies nobody' do
should_not_email_anyone
end
end
context 'when the creator has custom notifications, but without any set' do
before do
pipeline = create_pipeline(u_custom_notification_unset, :success)
notification.pipeline_finished(pipeline)
end
it 'notifies nobody' do
should_not_email_anyone
end
end
context 'when the creator has custom notifications disabled' do
before do
pipeline = create_pipeline(u_custom_notification_disabled, :success)
notification.pipeline_finished(pipeline)
end
it 'notifies nobody' do
should_not_email_anyone
end
end
context 'when the creator has custom notifications enabled' do
before do
pipeline = create_pipeline(u_custom_notification_enabled, :success)
notification.pipeline_finished(pipeline)
end
it 'emails only the creator' do
should_only_email(u_custom_notification_enabled, kind: :bcc)
end
end
end
context 'with a failed pipeline' do
context 'when the creator has no custom notification set' do
before do
pipeline = create_pipeline(u_member, :failed)
notification.pipeline_finished(pipeline)
end
it 'emails only the creator' do
should_only_email(u_member, kind: :bcc)
end
end
context 'when the creator has watch set' do
before do
pipeline = create_pipeline(u_watcher, :failed)
notification.pipeline_finished(pipeline)
end
it 'emails only the creator' do
should_only_email(u_watcher, kind: :bcc)
end
end
context 'when the creator has custom notifications, but without any set' do
before do
pipeline = create_pipeline(u_custom_notification_unset, :failed)
notification.pipeline_finished(pipeline)
end
it 'emails only the creator' do
should_only_email(u_custom_notification_unset, kind: :bcc)
end
end
context 'when the creator has custom notifications disabled' do
before do
pipeline = create_pipeline(u_custom_notification_disabled, :failed)
notification.pipeline_finished(pipeline)
end
it 'notifies nobody' do
should_not_email_anyone
end
end
context 'when the creator has custom notifications set' do
before do
pipeline = create_pipeline(u_custom_notification_enabled, :failed)
notification.pipeline_finished(pipeline)
end
it 'emails only the creator' do
should_only_email(u_custom_notification_enabled, kind: :bcc)
end
end
context 'when the creator has no read_build access' do
before do
pipeline = create_pipeline(u_member, :failed)
project.update(public_builds: false)
project.team.truncate
notification.pipeline_finished(pipeline)
end
it 'does not send emails' do
should_not_email_anyone
end
end
end
end
end
2018-03-17 18:26:18 +05:30
describe 'Pages domains' do
set(:project) { create(:project) }
set(:domain) { create(:pages_domain, project: project) }
set(:u_blocked) { create(:user, :blocked) }
set(:u_silence) { create_user_with_notification(:disabled, 'silent', project) }
set(:u_owner) { project.owner }
set(:u_master1) { create(:user) }
set(:u_master2) { create(:user) }
set(:u_developer) { create(:user) }
before do
project.add_master(u_blocked)
project.add_master(u_silence)
project.add_master(u_master1)
project.add_master(u_master2)
project.add_developer(u_developer)
reset_delivered_emails!
end
%i[
pages_domain_enabled
pages_domain_disabled
pages_domain_verification_succeeded
pages_domain_verification_failed
].each do |sym|
describe "##{sym}" do
subject(:notify!) { notification.send(sym, domain) }
it 'emails current watching masters' do
expect(Notify).to receive(:"#{sym}_email").at_least(:once).and_call_original
notify!
should_only_email(u_master1, u_master2, u_owner)
end
it 'emails nobody if the project is missing' do
domain.project = nil
notify!
should_not_email_anyone
end
end
end
describe '#pages_domain_verification_failed' do
it 'emails current watching masters' do
notification.pages_domain_verification_failed(domain)
should_only_email(u_master1, u_master2, u_owner)
end
end
describe '#pages_domain_enabled' do
it 'emails current watching masters' do
notification.pages_domain_enabled(domain)
should_only_email(u_master1, u_master2, u_owner)
end
end
describe '#pages_domain_disabled' do
it 'emails current watching masters' do
notification.pages_domain_disabled(domain)
should_only_email(u_master1, u_master2, u_owner)
end
end
end
2014-09-02 18:07:02 +05:30
def build_team(project)
@u_watcher = create_global_setting_for(create(:user), :watch)
@u_participating = create_global_setting_for(create(:user), :participating)
@u_participant_mentioned = create_global_setting_for(create(:user, username: 'participant'), :participating)
@u_disabled = create_global_setting_for(create(:user), :disabled)
@u_mentioned = create_global_setting_for(create(:user, username: 'mention'), :mention)
@u_committer = create(:user, username: 'committer')
@u_not_mentioned = create_global_setting_for(create(:user, username: 'regular'), :participating)
@u_outsider_mentioned = create(:user, username: 'outsider')
2016-06-22 15:30:34 +05:30
@u_custom_global = create_global_setting_for(create(:user, username: 'custom_global'), :custom)
# User to be participant by default
# This user does not contain any record in notification settings table
# It should be treated with a :participating notification_level
@u_lazy_participant = create(:user, username: 'lazy-participant')
2014-09-02 18:07:02 +05:30
2016-06-22 15:30:34 +05:30
@u_guest_watcher = create_user_with_notification(:watch, 'guest_watching')
@u_guest_custom = create_user_with_notification(:custom, 'guest_custom')
2016-06-02 11:05:42 +05:30
2017-08-17 22:00:37 +05:30
project.add_master(@u_watcher)
project.add_master(@u_participating)
project.add_master(@u_participant_mentioned)
project.add_master(@u_disabled)
project.add_master(@u_mentioned)
project.add_master(@u_committer)
project.add_master(@u_not_mentioned)
project.add_master(@u_lazy_participant)
project.add_master(@u_custom_global)
end
# Users in the project's group but not part of project's team
# with different notification settings
def build_group(project)
group = create(:group, :public)
project.group = group
# Group member: global=disabled, group=watch
@g_watcher = create_user_with_notification(:watch, 'group_watcher', project.group)
@g_watcher.notification_settings_for(nil).disabled!
# Group member: global=watch, group=global
@g_global_watcher = create_global_setting_for(create(:user), :watch)
group.add_users([@g_watcher, @g_global_watcher], :master)
group
end
def create_global_setting_for(user, level)
setting = user.global_notification_setting
setting.level = level
setting.save
user
2014-09-02 18:07:02 +05:30
end
2015-04-26 12:48:37 +05:30
2017-08-17 22:00:37 +05:30
def create_user_with_notification(level, username, resource = project)
2016-06-22 15:30:34 +05:30
user = create(:user, username: username)
2017-08-17 22:00:37 +05:30
setting = user.notification_settings_for(resource)
2016-06-22 15:30:34 +05:30
setting.level = level
setting.save
user
end
# Create custom notifications
# When resource is nil it means global notification
2017-08-17 22:00:37 +05:30
def update_custom_notification(event, user, resource: nil, value: true)
2016-06-22 15:30:34 +05:30
setting = user.notification_settings_for(resource)
2017-09-10 17:25:29 +05:30
setting.update!(event => value)
2016-06-02 11:05:42 +05:30
end
2015-04-26 12:48:37 +05:30
def add_users_with_subscription(project, issuable)
@subscriber = create :user
@unsubscriber = create :user
@subscribed_participant = create_global_setting_for(create(:user, username: 'subscribed_participant'), :participating)
@watcher_and_subscriber = create_global_setting_for(create(:user), :watch)
2015-04-26 12:48:37 +05:30
2017-08-17 22:00:37 +05:30
project.add_master(@subscribed_participant)
project.add_master(@subscriber)
project.add_master(@unsubscriber)
project.add_master(@watcher_and_subscriber)
2015-04-26 12:48:37 +05:30
2017-08-17 22:00:37 +05:30
issuable.subscriptions.create(user: @subscriber, project: project, subscribed: true)
issuable.subscriptions.create(user: @subscribed_participant, project: project, subscribed: true)
issuable.subscriptions.create(user: @unsubscriber, project: project, subscribed: false)
# Make the watcher a subscriber to detect dupes
2017-08-17 22:00:37 +05:30
issuable.subscriptions.create(user: @watcher_and_subscriber, project: project, subscribed: true)
2015-04-26 12:48:37 +05:30
end
2014-09-02 18:07:02 +05:30
end