1575 lines
53 KiB
Ruby
1575 lines
53 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
RSpec.describe UserNotifications do
|
|
let(:user) { Fabricate(:admin) }
|
|
|
|
describe "#get_context_posts" do
|
|
it "does not include hidden/deleted/user_deleted posts in context" do
|
|
post1 = create_post
|
|
_post2 = Fabricate(:post, topic: post1.topic, deleted_at: 1.day.ago)
|
|
_post3 = Fabricate(:post, topic: post1.topic, user_deleted: true)
|
|
_post4 = Fabricate(:post, topic: post1.topic, hidden: true)
|
|
_post5 = Fabricate(:post, topic: post1.topic, post_type: Post.types[:moderator_action])
|
|
_post6 = Fabricate(:post, topic: post1.topic, post_type: Post.types[:small_action])
|
|
_post7 = Fabricate(:post, topic: post1.topic, post_type: Post.types[:whisper])
|
|
last = Fabricate(:post, topic: post1.topic)
|
|
|
|
post1.user.user_option.email_previous_replies = UserOption.previous_replies_type[:always]
|
|
|
|
# default is only post #1
|
|
expect(UserNotifications.get_context_posts(last, nil, post1.user).count).to eq(1)
|
|
# staff members can also see the whisper
|
|
moderator = build(:moderator)
|
|
moderator.user_option = UserOption.new
|
|
moderator.user_option.email_previous_replies = UserOption.previous_replies_type[:always]
|
|
tu = TopicUser.new(topic: post1.topic, user: moderator)
|
|
expect(UserNotifications.get_context_posts(last, tu, tu.user).count).to eq(2)
|
|
end
|
|
|
|
it "allows users to control context" do
|
|
post1 = create_post
|
|
_post2 = Fabricate(:post, topic: post1.topic)
|
|
post3 = Fabricate(:post, topic: post1.topic)
|
|
|
|
user = Fabricate(:user)
|
|
TopicUser.change(user.id, post1.topic_id, last_emailed_post_number: 1)
|
|
topic_user = TopicUser.find_by(user_id: user.id, topic_id: post1.topic_id)
|
|
# to avoid reloads after update_columns
|
|
user = topic_user.user
|
|
user.user_option.update_columns(
|
|
email_previous_replies: UserOption.previous_replies_type[:unless_emailed],
|
|
)
|
|
|
|
expect(UserNotifications.get_context_posts(post3, topic_user, user).count).to eq(1)
|
|
|
|
user.user_option.update_columns(
|
|
email_previous_replies: UserOption.previous_replies_type[:never],
|
|
)
|
|
expect(UserNotifications.get_context_posts(post3, topic_user, user).count).to eq(0)
|
|
|
|
user.user_option.update_columns(
|
|
email_previous_replies: UserOption.previous_replies_type[:always],
|
|
)
|
|
expect(UserNotifications.get_context_posts(post3, topic_user, user).count).to eq(2)
|
|
|
|
SiteSetting.private_email = true
|
|
expect(UserNotifications.get_context_posts(post3, topic_user, user).count).to eq(0)
|
|
end
|
|
end
|
|
|
|
describe ".signup" do
|
|
subject(:email) { UserNotifications.signup(user) }
|
|
|
|
it "works" do
|
|
expect(email.to).to eq([user.email])
|
|
expect(email.subject).to be_present
|
|
expect(email.from).to eq([SiteSetting.notification_email])
|
|
expect(email.body).to be_present
|
|
end
|
|
end
|
|
|
|
describe ".forgot_password" do
|
|
subject(:email) { UserNotifications.forgot_password(user) }
|
|
|
|
it "works" do
|
|
expect(email.to).to eq([user.email])
|
|
expect(email.subject).to be_present
|
|
expect(email.from).to eq([SiteSetting.notification_email])
|
|
expect(email.body).to be_present
|
|
end
|
|
end
|
|
|
|
describe ".post_approved" do
|
|
fab!(:post)
|
|
|
|
it "works" do
|
|
subject =
|
|
UserNotifications.post_approved(user, { notification_data_hash: { post_url: post.url } })
|
|
|
|
expect(subject.to).to eq([user.email])
|
|
expect(subject.subject).to be_present
|
|
expect(subject.from).to eq([SiteSetting.notification_email])
|
|
expect(subject.body).to be_present
|
|
end
|
|
end
|
|
|
|
describe ".confirm_new_email" do
|
|
let(:opts) { { requested_by_admin: requested_by_admin, email_token: token } }
|
|
let(:token) { "test123" }
|
|
|
|
context "when requested by admin" do
|
|
let(:requested_by_admin) { true }
|
|
|
|
it "uses the requested by admin template" do
|
|
expect(UserNotifications.confirm_new_email(user, opts).body).to include(
|
|
"This email change was requested by a site admin.",
|
|
)
|
|
end
|
|
end
|
|
|
|
context "when not requested by admin" do
|
|
let(:requested_by_admin) { false }
|
|
|
|
it "uses the normal template" do
|
|
expect(UserNotifications.confirm_new_email(user, opts).body).not_to include(
|
|
"This email change was requested by a site admin.",
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe ".email_login" do
|
|
subject(:email) { UserNotifications.email_login(user, email_token: email_token) }
|
|
|
|
let(:email_token) do
|
|
Fabricate(:email_token, user: user, scope: EmailToken.scopes[:email_login]).token
|
|
end
|
|
|
|
it "generates the right email" do
|
|
expect(email.to).to eq([user.email])
|
|
expect(email.from).to eq([SiteSetting.notification_email])
|
|
|
|
expect(email.subject).to eq(
|
|
I18n.t("user_notifications.email_login.subject_template", email_prefix: SiteSetting.title),
|
|
)
|
|
|
|
expect(email.body.to_s).to match(
|
|
I18n.t(
|
|
"user_notifications.email_login.text_body_template",
|
|
site_name: SiteSetting.title,
|
|
base_url: Discourse.base_url,
|
|
email_token: email_token,
|
|
),
|
|
)
|
|
end
|
|
end
|
|
|
|
describe ".digest" do
|
|
subject(:email) { UserNotifications.digest(user) }
|
|
|
|
after { Discourse.redis.keys("summary-new-users:*").each { |key| Discourse.redis.del(key) } }
|
|
|
|
context "without new topics" do
|
|
it "doesn't send the email" do
|
|
expect(email.to).to be_blank
|
|
end
|
|
end
|
|
|
|
context "with topics only from new users" do
|
|
let!(:new_today) do
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user, trust_level: TrustLevel[0], created_at: 10.minutes.ago),
|
|
title: "Hey everyone look at me",
|
|
)
|
|
end
|
|
let!(:new_yesterday) do
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user, trust_level: TrustLevel[0], created_at: 25.hours.ago),
|
|
created_at: 25.hours.ago,
|
|
title: "This topic is of interest to you",
|
|
)
|
|
end
|
|
|
|
it "returns topics from new users if they're more than 24 hours old" do
|
|
expect(email.to).to eq([user.email])
|
|
html = email.html_part.body.to_s
|
|
expect(html).to include(new_yesterday.title)
|
|
expect(html).to_not include(new_today.title)
|
|
end
|
|
end
|
|
|
|
context "with new topics" do
|
|
fab!(:coding_horror)
|
|
|
|
let!(:popular_topic) { Fabricate(:topic, user: coding_horror, created_at: 1.hour.ago) }
|
|
|
|
let!(:another_popular_topic) do
|
|
Fabricate(:topic, user: coding_horror, created_at: 1.hour.ago)
|
|
end
|
|
|
|
let!(:post) { Fabricate(:post, topic: popular_topic, post_number: 1) }
|
|
|
|
let!(:another_post) { Fabricate(:post, topic: another_popular_topic, post_number: 1) }
|
|
|
|
it "works" do
|
|
expect(email.to).to eq([user.email])
|
|
expect(email.subject).to be_present
|
|
expect(email.from).to eq([SiteSetting.notification_email])
|
|
expect(email.html_part.body.to_s).to be_present
|
|
expect(email.text_part.body.to_s).to be_present
|
|
expect(email.header["List-Unsubscribe"].to_s).to match(/\/email\/unsubscribe\/\h{64}/)
|
|
expect(email.header["X-Discourse-Topic-Ids"].to_s).to eq(
|
|
"#{another_popular_topic.id},#{popular_topic.id}",
|
|
)
|
|
expect(email.header["X-Discourse-Post-Ids"].to_s).to eq("#{another_post.id},#{post.id}")
|
|
expect(email.html_part.body.to_s).to include("New Users")
|
|
end
|
|
|
|
it "doesn't include new user count if digest_after_minutes is low" do
|
|
user.user_option.digest_after_minutes = 60
|
|
expect(email.html_part.body.to_s).to_not include("New Users")
|
|
end
|
|
|
|
it "works with min_date string" do
|
|
digest = UserNotifications.digest(user, since: 1.month.ago.to_date.to_s)
|
|
expect(digest.html_part.body.to_s).to be_present
|
|
expect(digest.text_part.body.to_s).to be_present
|
|
expect(digest.html_part.body.to_s).to include("New Users")
|
|
end
|
|
|
|
it "includes email_prefix in email subject instead of site title" do
|
|
SiteSetting.email_prefix = "Try Discourse"
|
|
SiteSetting.title = "Discourse Meta"
|
|
|
|
expect(email.subject).to match(/Try Discourse/)
|
|
expect(email.subject).not_to match(/Discourse Meta/)
|
|
end
|
|
|
|
it "includes unread likes received count within the since date" do
|
|
Fabricate(
|
|
:notification,
|
|
user: user,
|
|
notification_type: Notification.types[:liked],
|
|
created_at: 2.months.ago,
|
|
)
|
|
Fabricate(
|
|
:notification,
|
|
user: user,
|
|
notification_type: Notification.types[:liked],
|
|
read: true,
|
|
)
|
|
Fabricate(:notification, user: user, notification_type: Notification.types[:liked])
|
|
Fabricate(:notification, user: user, notification_type: Notification.types[:liked])
|
|
digest = UserNotifications.digest(user, since: 1.month.ago.to_date.to_s)
|
|
parsed_html = Nokogiri::HTML5.fragment(digest.html_part.body.to_s)
|
|
expect(parsed_html.css(".header-stat-count #likes_received_stat_count strong").text).to eq(
|
|
"2",
|
|
)
|
|
expect(
|
|
parsed_html.css(".header-stat-description #likes_received_stat_description strong").text,
|
|
).to eq("Likes Received")
|
|
end
|
|
|
|
it "excludes deleted topics and their posts" do
|
|
deleted =
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user),
|
|
title: "Delete this topic plz",
|
|
created_at: 1.hour.ago,
|
|
)
|
|
post =
|
|
Fabricate(
|
|
:post,
|
|
topic: deleted,
|
|
score: 100.0,
|
|
post_number: 2,
|
|
raw: "Your wish is my command",
|
|
created_at: 1.hour.ago,
|
|
)
|
|
deleted.trash!
|
|
html = email.html_part.body.to_s
|
|
expect(html).to_not include deleted.title
|
|
expect(html).to_not include post.raw
|
|
end
|
|
|
|
it "excludes shared drafts" do
|
|
cat = Fabricate(:category)
|
|
SiteSetting.shared_drafts_category = cat.id
|
|
topic =
|
|
Fabricate(:topic, title: "This is a draft", category_id: cat.id, created_at: 1.hour.ago)
|
|
post =
|
|
Fabricate(
|
|
:post,
|
|
topic: topic,
|
|
score: 100.0,
|
|
post_number: 2,
|
|
raw: "secret draft content",
|
|
created_at: 1.hour.ago,
|
|
)
|
|
html = email.html_part.body.to_s
|
|
expect(html).to_not include topic.title
|
|
expect(html).to_not include post.raw
|
|
end
|
|
|
|
it "excludes whispers and other post types that don't belong" do
|
|
t =
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user),
|
|
title: "Who likes the same stuff I like?",
|
|
created_at: 1.hour.ago,
|
|
)
|
|
whisper =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 2,
|
|
raw: "You like weird stuff",
|
|
post_type: Post.types[:whisper],
|
|
created_at: 1.hour.ago,
|
|
)
|
|
mod_action =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 3,
|
|
raw: "This topic unlisted",
|
|
post_type: Post.types[:moderator_action],
|
|
created_at: 1.hour.ago,
|
|
)
|
|
small_action =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 4,
|
|
raw: "A small action",
|
|
post_type: Post.types[:small_action],
|
|
created_at: 1.hour.ago,
|
|
)
|
|
html = email.html_part.body.to_s
|
|
expect(html).to_not include whisper.raw
|
|
expect(html).to_not include mod_action.raw
|
|
expect(html).to_not include small_action.raw
|
|
end
|
|
|
|
it "excludes deleted and hidden posts" do
|
|
t =
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user),
|
|
title: "Post objectionable stuff here",
|
|
created_at: 1.hour.ago,
|
|
)
|
|
deleted =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 2,
|
|
raw: "This post is uncalled for",
|
|
deleted_at: 5.minutes.ago,
|
|
created_at: 1.hour.ago,
|
|
)
|
|
hidden =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 3,
|
|
raw: "Try to find this post",
|
|
hidden: true,
|
|
hidden_at: 5.minutes.ago,
|
|
hidden_reason_id: Post.hidden_reasons[:flagged_by_tl3_user],
|
|
created_at: 1.hour.ago,
|
|
)
|
|
user_deleted =
|
|
Fabricate(
|
|
:post,
|
|
topic: t,
|
|
score: 100.0,
|
|
post_number: 4,
|
|
raw: "I regret this post",
|
|
user_deleted: true,
|
|
created_at: 1.hour.ago,
|
|
)
|
|
html = email.html_part.body.to_s
|
|
expect(html).to_not include deleted.raw
|
|
expect(html).to_not include hidden.raw
|
|
expect(html).to_not include user_deleted.raw
|
|
end
|
|
|
|
it "excludes posts that are newer than editing grace period" do
|
|
SiteSetting.editing_grace_period = 5.minutes
|
|
too_new =
|
|
Fabricate(
|
|
:topic,
|
|
user: Fabricate(:user),
|
|
title: "Oops I need to edit this",
|
|
created_at: 1.minute.ago,
|
|
)
|
|
_too_new_post =
|
|
Fabricate(
|
|
:post,
|
|
user: too_new.user,
|
|
topic: too_new,
|
|
score: 100.0,
|
|
post_number: 1,
|
|
created_at: 1.minute.ago,
|
|
)
|
|
html = email.html_part.body.to_s
|
|
expect(html).to_not include too_new.title
|
|
end
|
|
|
|
it "uses theme color" do
|
|
cs =
|
|
Fabricate(
|
|
:color_scheme,
|
|
name: "Fancy",
|
|
color_scheme_colors: [
|
|
Fabricate(:color_scheme_color, name: "header_primary", hex: "F0F0F0"),
|
|
Fabricate(:color_scheme_color, name: "header_background", hex: "1E1E1E"),
|
|
],
|
|
)
|
|
theme =
|
|
Fabricate(:theme, user_selectable: true, user: Fabricate(:admin), color_scheme_id: cs.id)
|
|
|
|
theme.set_default!
|
|
|
|
html = email.html_part.body.to_s
|
|
expect(html).to include "F0F0F0"
|
|
expect(html).to include "1E1E1E"
|
|
end
|
|
|
|
it "supports subfolder" do
|
|
set_subfolder "/forum"
|
|
html = email.html_part.body.to_s
|
|
text = email.text_part.body.to_s
|
|
expect(html).to be_present
|
|
expect(text).to be_present
|
|
expect(html).to_not include("/forum/forum")
|
|
expect(text).to_not include("/forum/forum")
|
|
expect(email.header["List-Unsubscribe"].to_s).to match(
|
|
/http:\/\/test.localhost\/forum\/email\/unsubscribe\/\h{64}/,
|
|
)
|
|
|
|
topic_url = "http://test.localhost/forum/t/#{popular_topic.slug}/#{popular_topic.id}"
|
|
expect(html).to include(topic_url)
|
|
expect(text).to include(topic_url)
|
|
end
|
|
|
|
it "applies lang/xml:lang html attributes" do
|
|
SiteSetting.default_locale = "pl_PL"
|
|
html = email.html_part.to_s
|
|
|
|
expect(html).to match(' lang="pl-PL"')
|
|
expect(html).to match(' xml:lang="pl-PL"')
|
|
end
|
|
|
|
it "uses digest_attempted_at when user hasn't been seen in a while" do
|
|
user.update!(last_seen_at: 7.days.ago)
|
|
user.user_stat.update!(digest_attempted_at: 30.minutes.ago)
|
|
expect(email.to).to be_nil
|
|
end
|
|
|
|
it "uses last_seen_at when user has been sent a digest in a while" do
|
|
user.update!(last_seen_at: 30.minutes.ago)
|
|
user.user_stat.update!(digest_attempted_at: 7.days.ago)
|
|
expect(email.to).to be_nil
|
|
end
|
|
|
|
it "caps at 1 month when user has never been seen or sent a digest" do
|
|
old_topic = Fabricate(:topic, created_at: 2.months.ago)
|
|
|
|
user.update!(last_seen_at: nil)
|
|
user.user_stat.update!(digest_attempted_at: nil)
|
|
expect(email.to).to contain_exactly(user.email)
|
|
|
|
html = email.html_part.body.to_s
|
|
expect(html).not_to include(old_topic.title)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe ".user_replied" do
|
|
let(:response_by_user) { Fabricate(:user, name: "John Doe") }
|
|
let(:category) { Fabricate(:category, name: "India") }
|
|
let(:tag1) { Fabricate(:tag, name: "Taggo", public_topic_count: 1) }
|
|
let(:tag2) { Fabricate(:tag, name: "Taggie", public_topic_count: 3) }
|
|
let(:tag3) { Fabricate(:tag, name: "Teggo", public_topic_count: 2) }
|
|
|
|
let(:hidden_tag) { Fabricate(:tag, name: "hidden") }
|
|
let!(:hidden_tag_group) do
|
|
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
|
|
end
|
|
|
|
let(:topic) do
|
|
Fabricate(
|
|
:topic,
|
|
category: category,
|
|
tags: [tag1, tag2, tag3, hidden_tag],
|
|
title: "Super cool topic",
|
|
)
|
|
end
|
|
let(:post) { Fabricate(:post, topic: topic, raw: "This is My super duper cool topic") }
|
|
let(:response) { Fabricate(:basic_reply, topic: post.topic, user: response_by_user) }
|
|
let(:user) { Fabricate(:user) }
|
|
let(:notification) { Fabricate(:replied_notification, user: user, post: response) }
|
|
|
|
it "generates a correct email" do
|
|
SiteSetting.default_email_in_reply_to = true
|
|
|
|
# Fabricator is not fabricating this ...
|
|
SiteSetting.email_subject =
|
|
"[%{site_name}] %{optional_pm}%{optional_cat}%{optional_tags}%{topic_title}"
|
|
SiteSetting.enable_names = true
|
|
SiteSetting.display_name_on_posts = true
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
# from should include full user name
|
|
expect(mail[:from].display_names).to eql(["John Doe via Discourse"])
|
|
|
|
# subject should include category name
|
|
expect(mail.subject).to match(/India/)
|
|
|
|
# subject should include tag names
|
|
expect(mail.subject).to match(/Taggo/)
|
|
expect(mail.subject).to match(/Taggie/)
|
|
|
|
mail_html = mail.html_part.body.to_s
|
|
|
|
expect(mail_html.scan(/My super duper cool topic/).count).to eq(1)
|
|
expect(mail_html.scan(/In Reply To/).count).to eq(1)
|
|
|
|
# 2 "visit topic" link
|
|
expect(mail_html.scan(/Visit Topic/).count).to eq(2)
|
|
|
|
# 2 respond to links cause we have 1 context post
|
|
expect(mail_html.scan(/to respond/).count).to eq(2)
|
|
|
|
# 1 unsubscribe
|
|
expect(mail_html.scan(/To unsubscribe/).count).to eq(1)
|
|
|
|
# side effect, topic user is updated with post number
|
|
tu = TopicUser.get(post.topic_id, user)
|
|
expect(tu.last_emailed_post_number).to eq(response.post_number)
|
|
|
|
# no In Reply To if user opts out
|
|
user.user_option.email_in_reply_to = false
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.html_part.body.to_s.scan(/In Reply To/).count).to eq(0)
|
|
|
|
SiteSetting.enable_names = true
|
|
SiteSetting.display_name_on_posts = true
|
|
SiteSetting.prioritize_username_in_ux = false
|
|
|
|
response.user.username = "bobmarley"
|
|
response.user.name = "Bob Marley"
|
|
response.user.save
|
|
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
mail_html = mail.html_part.body.to_s
|
|
expect(mail_html.scan(/>Bob Marley/).count).to eq(1)
|
|
expect(mail_html.scan(/>bobmarley/).count).to eq(0)
|
|
|
|
expect(mail.subject.scan(/#{tag1.name}/).count).to eq(1)
|
|
expect(mail.subject.scan(/#{hidden_tag.name}/).count).to eq(0)
|
|
|
|
SiteSetting.prioritize_username_in_ux = true
|
|
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
mail_html = mail.html_part.body.to_s
|
|
expect(mail_html.scan(/>Bob Marley/).count).to eq(0)
|
|
expect(mail_html.scan(/>bobmarley/).count).to eq(1)
|
|
end
|
|
|
|
describe "number of tags shown in subject line" do
|
|
describe "max_tags_per_email_subject siteSetting enabled" do
|
|
before { SiteSetting.enable_max_tags_per_email_subject = true }
|
|
|
|
it "should match max_tags_per_email_subject" do
|
|
SiteSetting.email_subject =
|
|
"[%{site_name}] %{optional_pm}%{optional_cat}%{optional_tags}%{topic_title}"
|
|
SiteSetting.max_tags_per_topic = 1
|
|
SiteSetting.max_tags_per_email_subject = 2
|
|
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.subject).to eq(
|
|
"[Discourse] [#{category.name}] #{tag2.name} #{tag3.name} #{topic.title}",
|
|
)
|
|
end
|
|
end
|
|
|
|
describe "max_tags_per_email_subject siteSetting disabled" do
|
|
before { SiteSetting.enable_max_tags_per_email_subject = false }
|
|
|
|
it "should match max_tags_per_topic" do
|
|
SiteSetting.email_subject =
|
|
"[%{site_name}] %{optional_pm}%{optional_cat}%{optional_tags}%{topic_title}"
|
|
SiteSetting.max_tags_per_topic = 2
|
|
SiteSetting.max_tags_per_email_subject = 1
|
|
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.subject).to eq(
|
|
"[Discourse] [#{category.name}] #{tag2.name} #{tag3.name} #{topic.title}",
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
it "doesn't include details when private_email is enabled" do
|
|
SiteSetting.private_email = true
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.html_part.body.to_s).to_not include(response.raw)
|
|
expect(mail.html_part.body.to_s).to_not include(topic.url)
|
|
expect(mail.text_part.to_s).to_not include(response.raw)
|
|
expect(mail.text_part.to_s).to_not include(topic.url)
|
|
end
|
|
|
|
it "includes excerpt when post_excerpts_in_emails is enabled" do
|
|
paragraphs = [
|
|
"This is the first paragraph, but you should read more.",
|
|
"And here is its friend, the second paragraph.",
|
|
]
|
|
SiteSetting.post_excerpts_in_emails = true
|
|
SiteSetting.post_excerpt_maxlength = paragraphs.first.length
|
|
response.update!(raw: paragraphs.join("\n\n"))
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
mail_html = mail.html_part.body.to_s
|
|
expect(mail_html.scan(/#{paragraphs[0]}/).count).to eq(1)
|
|
expect(mail_html.scan(/#{paragraphs[1]}/).count).to eq(0)
|
|
end
|
|
end
|
|
|
|
describe ".user_posted" do
|
|
let(:response_by_user) { Fabricate(:user, name: "John Doe", username: "john") }
|
|
let(:topic) { Fabricate(:topic, title: "Super cool topic") }
|
|
let(:post) { Fabricate(:post, topic: topic) }
|
|
let(:response) { Fabricate(:post, topic: topic, user: response_by_user) }
|
|
let(:user) { Fabricate(:user) }
|
|
let(:notification) { Fabricate(:posted_notification, user: user, post: response) }
|
|
|
|
it "generates a correct email" do
|
|
SiteSetting.enable_names = false
|
|
mail =
|
|
UserNotifications.user_posted(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
# from should not include full user name if "show user full names" is disabled
|
|
expect(mail[:from].display_names).to_not eql(["John Doe"])
|
|
|
|
# from should include username if "show user full names" is disabled
|
|
expect(mail[:from].display_names).to eql(["john via Discourse"])
|
|
|
|
# subject should not include category name
|
|
expect(mail.subject).not_to match(/Uncategorized/)
|
|
|
|
# 1 respond to links as no context by default
|
|
expect(mail.html_part.body.to_s.scan(/to respond/).count).to eq(1)
|
|
|
|
# 1 unsubscribe link
|
|
expect(mail.html_part.body.to_s.scan(/To unsubscribe/).count).to eq(1)
|
|
|
|
# side effect, topic user is updated with post number
|
|
tu = TopicUser.get(post.topic_id, user)
|
|
expect(tu.last_emailed_post_number).to eq(response.post_number)
|
|
end
|
|
|
|
it "doesn't include details when private_email is enabled" do
|
|
SiteSetting.private_email = true
|
|
mail =
|
|
UserNotifications.user_posted(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.html_part.body.to_s).to_not include(response.raw)
|
|
expect(mail.text_part.to_s).to_not include(response.raw)
|
|
end
|
|
|
|
it "uses the original subject for staged users" do
|
|
incoming_email =
|
|
Fabricate(
|
|
:incoming_email,
|
|
subject: "Original Subject",
|
|
post: post,
|
|
topic: post.topic,
|
|
user: user,
|
|
)
|
|
|
|
mail =
|
|
UserNotifications.user_posted(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to match(/Super cool topic/)
|
|
|
|
user.update!(staged: true)
|
|
mail =
|
|
UserNotifications.user_posted(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to eq("Re: Original Subject")
|
|
|
|
another_post = Fabricate(:post, topic: topic)
|
|
incoming_email.update!(post_id: another_post.id)
|
|
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to match(/Super cool topic/)
|
|
end
|
|
end
|
|
|
|
describe ".user_private_message" do
|
|
let(:response_by_user) { Fabricate(:user, name: "", username: "john") }
|
|
let(:topic) { Fabricate(:private_message_topic, title: "Super cool topic") }
|
|
let(:post) { Fabricate(:post, topic: topic) }
|
|
let(:response) { Fabricate(:post, topic: topic, user: response_by_user) }
|
|
let(:user) { Fabricate(:user) }
|
|
let(:notification) { Fabricate(:private_message_notification, user: user, post: response) }
|
|
|
|
it "generates a correct email" do
|
|
SiteSetting.enable_names = true
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
# from should include username if full user name is not provided
|
|
expect(mail[:from].display_names).to eql(["john via Discourse"])
|
|
|
|
# subject should include "[PM]"
|
|
expect(mail.subject).to include("[PM] ")
|
|
|
|
# 1 "visit message" link
|
|
expect(mail.html_part.body.to_s.scan(/Visit Message/).count).to eq(1)
|
|
|
|
# 1 respond to link
|
|
expect(mail.html_part.body.to_s.scan(/to respond/).count).to eq(1)
|
|
|
|
# 1 unsubscribe link
|
|
expect(mail.html_part.body.to_s.scan(/To unsubscribe/).count).to eq(1)
|
|
|
|
# side effect, topic user is updated with post number
|
|
tu = TopicUser.get(topic.id, user)
|
|
expect(tu.last_emailed_post_number).to eq(response.post_number)
|
|
end
|
|
|
|
it "doesn't include details when private_email is enabled" do
|
|
SiteSetting.private_email = true
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.html_part.body.to_s).to_not include(response.raw)
|
|
expect(mail.html_part.body.to_s).to_not include(topic.url)
|
|
expect(mail.text_part.to_s).to_not include(response.raw)
|
|
expect(mail.text_part.to_s).to_not include(topic.url)
|
|
end
|
|
|
|
it "doesn't include group name in subject" do
|
|
group = Fabricate(:group)
|
|
topic.allowed_groups = [group]
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.subject).to include("[PM] ")
|
|
end
|
|
|
|
it "includes a list of participants (except for the destination user), groups first with member lists" do
|
|
group1 = Fabricate(:group, name: "group1")
|
|
group2 = Fabricate(:group, name: "group2")
|
|
|
|
user1 = Fabricate(:user, username: "one", groups: [group1, group2])
|
|
user2 = Fabricate(:user, username: "two", groups: [group1], staged: true)
|
|
|
|
topic.allowed_users = [user, user1, user2]
|
|
topic.allowed_groups = [group1, group2]
|
|
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
expect(mail.body).to include(
|
|
"[group1 (2)](http://test.localhost/g/group1), [group2 (1)](http://test.localhost/g/group2), [one](http://test.localhost/u/one), [two](http://test.localhost/u/two)",
|
|
)
|
|
end
|
|
|
|
context "when SiteSetting.group_name_in_subject is true" do
|
|
before { SiteSetting.group_in_subject = true }
|
|
|
|
let(:group) { Fabricate(:group, name: "my_group") }
|
|
let(:mail) do
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
end
|
|
|
|
shared_examples "includes first group name" do
|
|
it "includes first group name in subject" do
|
|
expect(mail.subject).to include("[my_group] ")
|
|
end
|
|
|
|
context "when first group has full name" do
|
|
it "includes full name in subject" do
|
|
group.full_name = "My Group"
|
|
group.save
|
|
expect(mail.subject).to include("[My Group] ")
|
|
end
|
|
end
|
|
end
|
|
|
|
context "with one group in pm" do
|
|
before { topic.allowed_groups = [group] }
|
|
|
|
include_examples "includes first group name"
|
|
end
|
|
|
|
context "with multiple groups in pm" do
|
|
let(:group2) { Fabricate(:group) }
|
|
|
|
before { topic.allowed_groups = [group, group2] }
|
|
|
|
include_examples "includes first group name"
|
|
end
|
|
|
|
context "with no groups in pm" do
|
|
it "includes %{optional_pm} in subject" do
|
|
expect(mail.subject).to include("[PM] ")
|
|
end
|
|
end
|
|
end
|
|
|
|
it "uses the original subject for staged users when topic was started via email" do
|
|
incoming_email =
|
|
Fabricate(
|
|
:incoming_email,
|
|
subject: "Original Subject",
|
|
post: post,
|
|
topic: topic,
|
|
user: user,
|
|
)
|
|
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to match(/Super cool topic/)
|
|
|
|
user.update!(staged: true)
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to eq("Re: Original Subject")
|
|
|
|
another_post = Fabricate(:post, topic: topic)
|
|
incoming_email.update!(post_id: another_post.id)
|
|
|
|
mail =
|
|
UserNotifications.user_private_message(
|
|
user,
|
|
post: response,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
expect(mail.subject).to match(/Super cool topic/)
|
|
end
|
|
end
|
|
|
|
it "adds a warning when mail limit is reached" do
|
|
SiteSetting.max_emails_per_day_per_user = 2
|
|
user = Fabricate(:user)
|
|
|
|
user.email_logs.create!(email_type: "blah", to_address: user.email, user_id: user.id)
|
|
|
|
post = Fabricate(:post)
|
|
reply = Fabricate(:post, topic_id: post.topic_id)
|
|
|
|
notification =
|
|
Fabricate(
|
|
:notification,
|
|
topic_id: post.topic_id,
|
|
post_number: reply.post_number,
|
|
user: post.user,
|
|
data: { original_username: "bob" }.to_json,
|
|
)
|
|
|
|
mail =
|
|
UserNotifications.user_replied(
|
|
user,
|
|
post: reply,
|
|
notification_type: notification.notification_type,
|
|
notification_data_hash: notification.data_hash,
|
|
)
|
|
|
|
# WARNING: you reached the limit of 100 email notifications per day. Further emails will be suppressed.
|
|
# Consider watching less topics or disabling mailing list mode.
|
|
expect(mail.html_part.body.to_s).to match(I18n.t("user_notifications.reached_limit", count: 2))
|
|
expect(mail.body.to_s).to match(I18n.t("user_notifications.reached_limit", count: 2))
|
|
end
|
|
|
|
def expects_build_with(condition)
|
|
UserNotifications.any_instance.expects(:build_email).with(user.email, condition)
|
|
mailer =
|
|
UserNotifications.public_send(
|
|
mail_type,
|
|
user,
|
|
notification_type: Notification.types[notification.notification_type],
|
|
notification_data_hash: notification.data_hash,
|
|
post: notification.post,
|
|
)
|
|
|
|
mailer.message
|
|
end
|
|
|
|
shared_examples "supports reply by email" do
|
|
context "with reply_by_email" do
|
|
it "should have allow_reply_by_email set when that feature is enabled" do
|
|
expects_build_with(has_entry(:allow_reply_by_email, true))
|
|
end
|
|
end
|
|
end
|
|
|
|
shared_examples "no reply by email" do
|
|
context "with reply_by_email" do
|
|
it "doesn't support reply by email" do
|
|
expects_build_with(Not(has_entry(:allow_reply_by_email, true)))
|
|
end
|
|
end
|
|
end
|
|
|
|
shared_examples "respect for private_email" do
|
|
context "with private_email" do
|
|
it "doesn't support reply by email" do
|
|
SiteSetting.private_email = true
|
|
|
|
mailer =
|
|
UserNotifications.public_send(
|
|
mail_type,
|
|
user,
|
|
notification_type: Notification.types[notification.notification_type],
|
|
notification_data_hash: notification.data_hash,
|
|
post: notification.post,
|
|
)
|
|
message = mailer.message
|
|
|
|
topic = notification.post.topic
|
|
expect(message.html_part.body.to_s).not_to include(topic.title)
|
|
expect(message.html_part.body.to_s).not_to include(topic.slug)
|
|
expect(message.text_part.body.to_s).not_to include(topic.title)
|
|
expect(message.text_part.body.to_s).not_to include(topic.slug)
|
|
end
|
|
end
|
|
end
|
|
|
|
# The parts of emails that are derived from templates are translated
|
|
shared_examples "sets user locale" do
|
|
context "with set locale for translating templates" do
|
|
it "sets the locale" do
|
|
expects_build_with(has_key(:locale))
|
|
end
|
|
end
|
|
end
|
|
|
|
shared_examples "notification email building" do
|
|
let(:post) { Fabricate(:post, user: user) }
|
|
let(:mail_type) { "user_#{notification_type}" }
|
|
let(:mail_template) { "user_notifications.#{mail_type}" }
|
|
let(:username) { "walterwhite" }
|
|
let(:notification) do
|
|
Fabricate(
|
|
:notification,
|
|
user: user,
|
|
topic: post.topic,
|
|
notification_type: Notification.types[notification_type],
|
|
post_number: post.post_number,
|
|
data: { original_username: username }.to_json,
|
|
)
|
|
end
|
|
|
|
describe "email building" do
|
|
it "has a username" do
|
|
expects_build_with(has_entry(:username, username))
|
|
end
|
|
|
|
it "has a url" do
|
|
expects_build_with(has_key(:url))
|
|
end
|
|
|
|
it "has a template" do
|
|
expects_build_with(has_entry(:template, mail_template))
|
|
end
|
|
|
|
it "overrides the html part" do
|
|
expects_build_with(has_key(:html_override))
|
|
end
|
|
|
|
it "has a message" do
|
|
expects_build_with(has_key(:message))
|
|
end
|
|
|
|
it "has a context" do
|
|
expects_build_with(has_key(:context))
|
|
end
|
|
|
|
it "has an unsubscribe link" do
|
|
expects_build_with(has_key(:add_unsubscribe_link))
|
|
end
|
|
|
|
it "has an post_id" do
|
|
expects_build_with(has_key(:post_id))
|
|
end
|
|
|
|
it "has an topic_id" do
|
|
expects_build_with(has_key(:topic_id))
|
|
end
|
|
|
|
it "should have user name as from_alias" do
|
|
SiteSetting.enable_names = true
|
|
SiteSetting.display_name_on_posts = true
|
|
expects_build_with(has_entry(:from_alias, "#{user.name} via Discourse"))
|
|
end
|
|
|
|
it "should not have user name as from_alias if display_name_on_posts is disabled" do
|
|
SiteSetting.enable_names = false
|
|
SiteSetting.display_name_on_posts = false
|
|
expects_build_with(has_entry(:from_alias, "walterwhite via Discourse"))
|
|
end
|
|
|
|
it "should explain how to respond" do
|
|
expects_build_with(Not(has_entry(:include_respond_instructions, false)))
|
|
end
|
|
|
|
it "should not explain how to respond if the user is suspended" do
|
|
User.any_instance.stubs(:suspended?).returns(true)
|
|
expects_build_with(has_entry(:include_respond_instructions, false))
|
|
end
|
|
|
|
context "when customized" do
|
|
let(:custom_body) do
|
|
body = +<<~BODY
|
|
You are now officially notified.
|
|
%{header_instructions}
|
|
%{message} %{respond_instructions}
|
|
%{topic_title_url_encoded}
|
|
%{site_title_url_encoded}
|
|
BODY
|
|
|
|
body << "%{context}" if notification_type != :invited_to_topic
|
|
body
|
|
end
|
|
|
|
before do
|
|
TranslationOverride.upsert!(
|
|
SiteSetting.default_locale,
|
|
"#{mail_template}.text_body_template",
|
|
custom_body,
|
|
)
|
|
end
|
|
|
|
it "shouldn't use the default html_override" do
|
|
expects_build_with(Not(has_key(:html_override)))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "user mentioned email" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :mentioned }
|
|
include_examples "respect for private_email"
|
|
include_examples "supports reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "group mentioned email" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :group_mentioned }
|
|
let(:post) { Fabricate(:private_message_post) }
|
|
let(:user) { post.user }
|
|
let(:mail_type) { "group_mentioned" }
|
|
let(:mail_template) { "user_notifications.user_#{notification_type}_pm" }
|
|
|
|
include_examples "respect for private_email"
|
|
include_examples "supports reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "user replied" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :replied }
|
|
include_examples "respect for private_email"
|
|
include_examples "supports reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "user quoted" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :quoted }
|
|
include_examples "respect for private_email"
|
|
include_examples "supports reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "user posted" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :posted }
|
|
include_examples "respect for private_email"
|
|
include_examples "supports reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "user invited to a private message" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :invited_to_private_message }
|
|
let(:post) { Fabricate(:private_message_post) }
|
|
let(:user) { post.user }
|
|
let(:mail_template) { "user_notifications.user_#{notification_type}_pm" }
|
|
|
|
include_examples "respect for private_email"
|
|
include_examples "no reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "group invited to a private message" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :invited_to_private_message }
|
|
let(:post) { Fabricate(:private_message_post) }
|
|
let(:user) { post.user }
|
|
let(:group) { Fabricate(:group) }
|
|
let(:mail_template) { "user_notifications.user_#{notification_type}_pm_group" }
|
|
|
|
before do
|
|
notification.data_hash[:group_id] = group.id
|
|
notification.save!
|
|
end
|
|
|
|
it "should include the group name" do
|
|
expects_build_with(has_entry(:group_name, group.name))
|
|
end
|
|
|
|
include_examples "respect for private_email"
|
|
include_examples "no reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
describe "user invited to a topic" do
|
|
let(:notification_type) { :invited_to_topic }
|
|
|
|
include_examples "notification email building" do
|
|
include_examples "respect for private_email"
|
|
include_examples "no reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
|
|
context "when showing the right name in 'From' field" do
|
|
let(:inviter) { Fabricate(:user) }
|
|
let(:invitee) { Fabricate(:user) }
|
|
|
|
let(:notification) do
|
|
Fabricate(
|
|
:notification,
|
|
notification_type: Notification.types[:invited_to_topic],
|
|
user: invitee,
|
|
topic: post.topic,
|
|
post_number: post.post_number,
|
|
data: {
|
|
topic_title: post.topic.title,
|
|
display_username: inviter.username,
|
|
original_user_id: inviter.id,
|
|
original_username: inviter.username,
|
|
}.to_json,
|
|
)
|
|
end
|
|
|
|
let(:mailer) do
|
|
UserNotifications.public_send(
|
|
"user_invited_to_topic",
|
|
invitee,
|
|
notification_type: Notification.types[notification.notification_type],
|
|
notification_data_hash: notification.data_hash,
|
|
post: notification.post,
|
|
)
|
|
end
|
|
|
|
it "sends the email as the inviter" do
|
|
SiteSetting.enable_names = false
|
|
|
|
expect(mailer.message.to_s).to include(
|
|
"From: #{inviter.username} via #{SiteSetting.title} <#{SiteSetting.notification_email}>",
|
|
)
|
|
end
|
|
|
|
it "sends the email as the inviter" do
|
|
expect(mailer.message.to_s).to include(
|
|
"From: #{inviter.name} via #{SiteSetting.title} <#{SiteSetting.notification_email}>",
|
|
)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "watching first post" do
|
|
include_examples "notification email building" do
|
|
let(:notification_type) { :invited_to_topic }
|
|
include_examples "respect for private_email"
|
|
include_examples "no reply by email"
|
|
include_examples "sets user locale"
|
|
end
|
|
end
|
|
|
|
# notification emails derived from templates are translated into the user's locale
|
|
shared_context "with notification derived from template" do
|
|
let(:user) { Fabricate(:user, locale: locale) }
|
|
let(:mail_type) { mail_type }
|
|
let(:notification) { Fabricate(:notification, user: user) }
|
|
end
|
|
|
|
describe "notifications from template" do
|
|
context "when user locale is allowed" do
|
|
before { SiteSetting.allow_user_locale = true }
|
|
|
|
%w[
|
|
signup
|
|
signup_after_approval
|
|
confirm_old_email
|
|
notify_old_email
|
|
confirm_new_email
|
|
forgot_password
|
|
admin_login
|
|
account_created
|
|
].each do |mail_type|
|
|
include_examples "with notification derived from template" do
|
|
let(:locale) { "fr" }
|
|
let(:mail_type) { mail_type }
|
|
it "sets the locale" do
|
|
expects_build_with(has_entry(:locale, "fr"))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
context "when user locale is not allowed" do
|
|
before { SiteSetting.allow_user_locale = false }
|
|
|
|
%w[
|
|
signup
|
|
signup_after_approval
|
|
notify_old_email
|
|
confirm_old_email
|
|
confirm_new_email
|
|
forgot_password
|
|
admin_login
|
|
account_created
|
|
].each do |mail_type|
|
|
include_examples "with notification derived from template" do
|
|
let(:locale) { "fr" }
|
|
let(:mail_type) { mail_type }
|
|
it "sets the locale" do
|
|
expects_build_with(has_entry(:locale, "en"))
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
describe "#participants" do
|
|
fab!(:group1) { Fabricate(:group, name: "group1") }
|
|
fab!(:group2) { Fabricate(:group, name: "group2") }
|
|
fab!(:group3) { Fabricate(:group, name: "group3") }
|
|
fab!(:user1) { Fabricate(:user, username: "one", name: nil, groups: [group1, group2]) }
|
|
fab!(:user2) { Fabricate(:user, username: "two", name: nil, groups: [group1]) }
|
|
fab!(:user3) { Fabricate(:user, username: "three", name: nil, groups: [group3]) }
|
|
fab!(:user4) { Fabricate(:user, username: "four", name: nil, groups: [group1, group3]) }
|
|
fab!(:admin) { Fabricate(:admin, username: "admin", name: nil) }
|
|
|
|
fab!(:topic) do
|
|
t = Fabricate(:private_message_topic, title: "Super cool topic")
|
|
t.allowed_users = [user1, user2, user3, user4, admin]
|
|
t.allowed_groups = [group1]
|
|
t
|
|
end
|
|
fab!(:posts) do
|
|
[
|
|
Fabricate(:post, topic: topic, post_number: 1, user: user2),
|
|
Fabricate(:post, topic: topic, post_number: 2, user: user1),
|
|
Fabricate(:post, topic: topic, post_number: 3, user: user2),
|
|
Fabricate(:small_action, topic: topic, post_number: 4, user: admin),
|
|
Fabricate(:post, topic: topic, post_number: 5, user: user4),
|
|
Fabricate(:post, topic: topic, post_number: 6, user: user3),
|
|
Fabricate(:post, topic: topic, post_number: 7, user: user4),
|
|
]
|
|
end
|
|
|
|
it "returns a list of participants (except for the recipient), groups first, followed by users in order of their last reply" do
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), " \
|
|
"[four](http://test.localhost/u/four), [two](http://test.localhost/u/two), [one](http://test.localhost/u/one), " \
|
|
"[admin](http://test.localhost/u/admin)",
|
|
)
|
|
end
|
|
|
|
it "caps the list according to site setting" do
|
|
SiteSetting.max_participant_names = 3
|
|
list =
|
|
"[group1 (3)](http://test.localhost/g/group1), [four](http://test.localhost/u/four), [two](http://test.localhost/u/two)"
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
I18n.t("user_notifications.more_pm_participants", participants: list, count: 2),
|
|
)
|
|
end
|
|
|
|
it "orders groups by user count" do
|
|
SiteSetting.max_participant_names = 3
|
|
topic.allowed_groups = [group1, group2, group3]
|
|
|
|
list =
|
|
"[group1 (3)](http://test.localhost/g/group1), [group3 (2)](http://test.localhost/g/group3), [group2 (1)](http://test.localhost/g/group2)"
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
I18n.t("user_notifications.more_pm_participants", participants: list, count: 4),
|
|
)
|
|
end
|
|
|
|
it "orders users by their last reply and user id" do
|
|
expect(UserNotifications.participants(posts[-3], user4)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), " \
|
|
"[two](http://test.localhost/u/two), [one](http://test.localhost/u/one), [three](http://test.localhost/u/three), " \
|
|
"[admin](http://test.localhost/u/admin)",
|
|
)
|
|
end
|
|
|
|
it "prefers full group names when available" do
|
|
SiteSetting.max_participant_names = 2
|
|
topic.allowed_groups = [group1, group2]
|
|
|
|
group2.update!(full_name: "Awesome Group")
|
|
|
|
list =
|
|
"[group1 (3)](http://test.localhost/g/group1), [Awesome Group (1)](http://test.localhost/g/group2)"
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
I18n.t("user_notifications.more_pm_participants", participants: list, count: 4),
|
|
)
|
|
end
|
|
|
|
it "always uses usernames when prioritize_username_in_ux is enabled" do
|
|
user4.update!(name: "James Bond")
|
|
user1.update!(name: "Indiana Jones")
|
|
|
|
SiteSetting.prioritize_username_in_ux = true
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), " \
|
|
"[four](http://test.localhost/u/four), [two](http://test.localhost/u/two), [one](http://test.localhost/u/one), " \
|
|
"[admin](http://test.localhost/u/admin)",
|
|
)
|
|
|
|
SiteSetting.prioritize_username_in_ux = false
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), " \
|
|
"[James Bond](http://test.localhost/u/four), [two](http://test.localhost/u/two), [Indiana Jones](http://test.localhost/u/one), " \
|
|
"[admin](http://test.localhost/u/admin)",
|
|
)
|
|
end
|
|
|
|
it "reveals the email address of staged users if enabled" do
|
|
user4.update!(staged: true, email: "james.bond@mi6.invalid")
|
|
user1.update!(staged: true, email: "indiana.jones@example.com")
|
|
|
|
SiteSetting.prioritize_username_in_ux = true
|
|
expect(UserNotifications.participants(posts.last, user3, reveal_staged_email: true)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), james.bond@mi6.invalid, [two](http://test.localhost/u/two), " \
|
|
"indiana.jones@example.com, [admin](http://test.localhost/u/admin)",
|
|
)
|
|
end
|
|
|
|
it "does only include human users" do
|
|
topic.allowed_users << Discourse.system_user
|
|
|
|
expect(UserNotifications.participants(posts.last, user3)).to eq(
|
|
"[group1 (3)](http://test.localhost/g/group1), " \
|
|
"[four](http://test.localhost/u/four), [two](http://test.localhost/u/two), [one](http://test.localhost/u/one), " \
|
|
"[admin](http://test.localhost/u/admin)",
|
|
)
|
|
end
|
|
end
|
|
|
|
describe ".account_silenced" do
|
|
fab!(:user_history) { Fabricate(:user_history, action: UserHistory.actions[:silence_user]) }
|
|
|
|
it "adds the silenced_till date in user's timezone" do
|
|
user.user_option.timezone = "Asia/Tbilisi" # GMT+4
|
|
user.silenced_till = DateTime.parse("May 25, 2020, 12:00pm")
|
|
|
|
mail = UserNotifications.account_silenced(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include("May 25, 2020, 4:00pm")
|
|
end
|
|
|
|
context "when user doesn't have timezone set" do
|
|
before { user.user_option.timezone = nil }
|
|
|
|
it "doesn't raise error" do
|
|
expect { UserNotifications.account_silenced(user) }.not_to raise_error
|
|
end
|
|
|
|
it "adds the silenced_till date in UTC" do
|
|
date = "May 25, 2020, 12:00pm"
|
|
user.silenced_till = DateTime.parse(date)
|
|
|
|
mail = UserNotifications.account_silenced(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include(date)
|
|
end
|
|
end
|
|
|
|
context "when user timezone is invalid" do
|
|
before { user.user_option.timezone = "" }
|
|
|
|
it "doesn't raise error" do
|
|
expect { UserNotifications.account_silenced(user) }.not_to raise_error
|
|
end
|
|
|
|
it "adds the silenced_till date in UTC" do
|
|
date = "May 25, 2020, 12:00pm"
|
|
user.silenced_till = DateTime.parse(date)
|
|
|
|
mail = UserNotifications.account_silenced(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include(date)
|
|
end
|
|
end
|
|
end
|
|
|
|
describe ".account_suspended" do
|
|
fab!(:user_history) { Fabricate(:user_history, action: UserHistory.actions[:suspend_user]) }
|
|
|
|
it "adds the suspended_till date in user's timezone" do
|
|
user.user_option.timezone = "Asia/Tbilisi" # GMT+4
|
|
user.suspended_till = DateTime.parse("May 25, 2020, 12:00pm")
|
|
|
|
mail = UserNotifications.account_suspended(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include("May 25, 2020, 4:00pm")
|
|
end
|
|
|
|
context "when user doesn't have timezone set" do
|
|
before { user.user_option.timezone = nil }
|
|
|
|
it "doesn't raise error" do
|
|
expect { UserNotifications.account_suspended(user) }.not_to raise_error
|
|
end
|
|
|
|
it "adds the suspended_till date in UTC" do
|
|
date = "May 25, 2020, 12:00pm"
|
|
user.suspended_till = DateTime.parse(date)
|
|
|
|
mail = UserNotifications.account_suspended(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include(date)
|
|
end
|
|
end
|
|
|
|
context "when user timezone is invalid" do
|
|
before { user.user_option.timezone = "" }
|
|
|
|
it "doesn't raise error" do
|
|
expect { UserNotifications.account_suspended(user) }.not_to raise_error
|
|
end
|
|
|
|
it "adds the suspended_till date in UTC" do
|
|
date = "May 25, 2020, 12:00pm"
|
|
user.suspended_till = DateTime.parse(date)
|
|
|
|
mail = UserNotifications.account_suspended(user, { user_history: user_history })
|
|
|
|
expect(mail.body).to include(date)
|
|
end
|
|
end
|
|
end
|
|
end
|