Mirror
/
zulip
mirror of https://github.com/zulip/zulip.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

mention: Replace 'wildcards' with 'stream_wildcards'. 

This prep commit replaces the 'wildcard' keyword in the codebase
with 'stream_wildcard' at some places for better readability, as
we plan to introduce 'topic_wildcards' as a part of the
'@topic mention' project.

Currently, 'wildcards = ["all", "everyone", "stream"]' which is an
alias to mention everyone in the stream, hence better renamed as
'stream_wildcards'.

Eventually, we will have:
'stream_wildcard' as an alias to mention everyone in the stream.
'topic_wildcard' as an alias to mention everyone in the topic.
'wildcard' refers to 'stream_wildcard' and 'topic_wildcard' as a whole.
This commit is contained in:
Prakhar Pratyush 2023-06-03 20:21:38 +05:30 committed by Tim Abbott
parent d80779435a
commit 179d5cb37d
28 changed files with 444 additions and 320 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
templates/zerver/emails/missed_message.html
View File

@ -29,9 +29,9 @@
{% trans %}You are receiving this because you were personally mentioned.{% endtrans %}<br />
{% elif mentioned_user_group_name %}
{% trans %}You are receiving this because @{{ mentioned_user_group_name }} was mentioned.{% endtrans %}<br />
{% elif followed_topic_wildcard_mentioned %}
{% elif stream_wildcard_mentioned_in_followed_topic %}
{% trans %}You are receiving this because you have wildcard mention notifications enabled for topics you follow.{% endtrans %}<br />
{% elif wildcard_mentioned %}
{% elif stream_wildcard_mentioned %}
{% trans %}You are receiving this because everyone was mentioned in #{{ stream_name }}.{% endtrans %}<br />
{% elif followed_topic_email_notify %}
{% trans %}You are receiving this because you have email notifications enabled for topics you follow.{% endtrans %}<br />

4
templates/zerver/emails/missed_message.txt
View File

@ -25,9 +25,9 @@ See {{ alert_notif_url }} for more details.
{% trans %}You are receiving this because you were personally mentioned.{% endtrans %}
{% elif mentioned_user_group_name %}
{% trans %}You are receiving this because @{{ mentioned_user_group_name }} was mentioned.{% endtrans %}
{% elif followed_topic_wildcard_mentioned %}
{% elif stream_wildcard_mentioned_in_followed_topic %}
{% trans %}You are receiving this because you have wildcard mention notifications enabled for topics you follow.{% endtrans %}
{% elif wildcard_mentioned %}
{% elif stream_wildcard_mentioned %}
{% trans %}You are receiving this because everyone was mentioned in #{{ stream_name }}.{% endtrans %}
{% elif followed_topic_email_notify %}
{% trans %}You are receiving this because you have email notifications enabled for topics you follow.{% endtrans %}

18
zerver/actions/message_edit.py
View File

@ -258,7 +258,7 @@ def get_mentions_for_message_updates(message_id: int) -> Set[int]:
def update_user_message_flags(
rendering_result: MessageRenderingResult, ums: Iterable[UserMessage]
) -> None:
wildcard = rendering_result.mentions_wildcard
wildcard = rendering_result.mentions_stream_wildcard
mentioned_ids = rendering_result.mentions_user_ids
ids_with_alert_words = rendering_result.user_ids_with_alert_words
changed_ums: Set[UserMessage] = set()
@ -466,7 +466,7 @@ def do_update_message(
recipient=target_message.recipient,
sender_id=target_message.sender_id,
stream_topic=stream_topic,
possible_wildcard_mention=mention_data.message_has_wildcards(),
possible_stream_wildcard_mention=mention_data.message_has_stream_wildcards(),
)
event["online_push_user_ids"] = list(info.online_push_user_ids)
@ -480,14 +480,14 @@ def do_update_message(
event["prior_mention_user_ids"] = list(prior_mention_user_ids)
event["presence_idle_user_ids"] = filter_presence_idle_user_ids(info.active_user_ids)
event["all_bot_user_ids"] = list(info.all_bot_user_ids)
if rendering_result.mentions_wildcard:
event["wildcard_mention_user_ids"] = list(info.wildcard_mention_user_ids)
event["followed_topic_wildcard_mention_user_ids"] = list(
info.followed_topic_wildcard_mention_user_ids
if rendering_result.mentions_stream_wildcard:
event["stream_wildcard_mention_user_ids"] = list(info.stream_wildcard_mention_user_ids)
event["stream_wildcard_mention_in_followed_topic_user_ids"] = list(
info.stream_wildcard_mention_in_followed_topic_user_ids
)
else:
event["wildcard_mention_user_ids"] = []
event["followed_topic_wildcard_mention_user_ids"] = []
event["stream_wildcard_mention_user_ids"] = []
event["stream_wildcard_mention_in_followed_topic_user_ids"] = []
do_update_mobile_push_notification(
target_message,
@ -1248,7 +1248,7 @@ def check_update_message(
)
links_for_embed |= rendering_result.links_for_preview
if message.is_stream_message() and rendering_result.mentions_wildcard:
if message.is_stream_message() and rendering_result.mentions_stream_wildcard:
stream = access_stream_by_id(user_profile, message.recipient.type_id)[0]
if not wildcard_mention_allowed(message.sender, stream):
raise JsonableError(

66
zerver/actions/message_send.py
View File

@ -166,10 +166,10 @@ class RecipientInfoResult:
pm_mention_push_disabled_user_ids: Set[int]
stream_email_user_ids: Set[int]
stream_push_user_ids: Set[int]
wildcard_mention_user_ids: Set[int]
stream_wildcard_mention_user_ids: Set[int]
followed_topic_email_user_ids: Set[int]
followed_topic_push_user_ids: Set[int]
followed_topic_wildcard_mention_user_ids: Set[int]
stream_wildcard_mention_in_followed_topic_user_ids: Set[int]
muted_sender_user_ids: Set[int]
um_eligible_user_ids: Set[int]
long_term_idle_user_ids: Set[int]
@ -195,14 +195,14 @@ def get_recipient_info(
sender_id: int,
stream_topic: Optional[StreamTopicTarget],
possibly_mentioned_user_ids: AbstractSet[int] = set(),
possible_wildcard_mention: bool = True,
possible_stream_wildcard_mention: bool = True,
) -> RecipientInfoResult:
stream_push_user_ids: Set[int] = set()
stream_email_user_ids: Set[int] = set()
wildcard_mention_user_ids: Set[int] = set()
stream_wildcard_mention_user_ids: Set[int] = set()
followed_topic_push_user_ids: Set[int] = set()
followed_topic_email_user_ids: Set[int] = set()
followed_topic_wildcard_mention_user_ids: Set[int] = set()
stream_wildcard_mention_in_followed_topic_user_ids: Set[int] = set()
muted_sender_user_ids: Set[int] = get_muting_users(sender_id)
if recipient.type == Recipient.PERSONAL:
@ -222,7 +222,7 @@ def get_recipient_info(
realm_id=realm_id,
stream_id=stream_topic.stream_id,
topic_name=stream_topic.topic_name,
possible_wildcard_mention=possible_wildcard_mention,
possible_stream_wildcard_mention=possible_stream_wildcard_mention,
possibly_mentioned_user_ids=possibly_mentioned_user_ids,
)
.annotate(
@ -293,14 +293,14 @@ def get_recipient_info(
)
followed_topic_push_user_ids = followed_topic_notification_recipients("push_notifications")
if possible_wildcard_mention:
# We calculate `wildcard_mention_user_ids` and `followed_topic_wildcard_mention_user_ids`
# only if there's a possible wildcard mention in the message. This is important so as
if possible_stream_wildcard_mention:
# We calculate `stream_wildcard_mention_user_ids` and `followed_topic_wildcard_mention_user_ids`
# only if there's a possible stream wildcard mention in the message. This is important so as
# to avoid unnecessarily sending huge user ID lists with thousands of elements to the
# event queue (which can happen because these settings are `True` by default for new users.)
wildcard_mention_user_ids = notification_recipients("wildcard_mentions_notify")
followed_topic_wildcard_mention_user_ids = followed_topic_notification_recipients(
"wildcard_mentions_notify"
stream_wildcard_mention_user_ids = notification_recipients("wildcard_mentions_notify")
stream_wildcard_mention_in_followed_topic_user_ids = (
followed_topic_notification_recipients("wildcard_mentions_notify")
)
elif recipient.type == Recipient.HUDDLE:
@ -418,10 +418,10 @@ def get_recipient_info(
pm_mention_push_disabled_user_ids=pm_mention_push_disabled_user_ids,
stream_push_user_ids=stream_push_user_ids,
stream_email_user_ids=stream_email_user_ids,
wildcard_mention_user_ids=wildcard_mention_user_ids,
stream_wildcard_mention_user_ids=stream_wildcard_mention_user_ids,
followed_topic_push_user_ids=followed_topic_push_user_ids,
followed_topic_email_user_ids=followed_topic_email_user_ids,
followed_topic_wildcard_mention_user_ids=followed_topic_wildcard_mention_user_ids,
stream_wildcard_mention_in_followed_topic_user_ids=stream_wildcard_mention_in_followed_topic_user_ids,
muted_sender_user_ids=muted_sender_user_ids,
um_eligible_user_ids=um_eligible_user_ids,
long_term_idle_user_ids=long_term_idle_user_ids,
@ -541,7 +541,7 @@ def build_message_send_dict(
sender_id=message.sender_id,
stream_topic=stream_topic,
possibly_mentioned_user_ids=mention_data.get_user_ids(),
possible_wildcard_mention=mention_data.message_has_wildcards(),
possible_stream_wildcard_mention=mention_data.message_has_stream_wildcards(),
)
# Render our message_dicts.
@ -570,16 +570,18 @@ def build_message_send_dict(
members = mention_data.get_group_members(group_id)
rendering_result.mentions_user_ids.update(members)
# Only send data to Tornado about wildcard mentions if message
# rendering determined the message had an actual wildcard
# mention in it (and not e.g. wildcard mention syntax inside a
# Only send data to Tornado about stream wildcard mentions if message
# rendering determined the message had an actual stream wildcard
# mention in it (and not e.g. stream wildcard mention syntax inside a
# code block).
if rendering_result.mentions_wildcard:
wildcard_mention_user_ids = info.wildcard_mention_user_ids
followed_topic_wildcard_mention_user_ids = info.followed_topic_wildcard_mention_user_ids
if rendering_result.mentions_stream_wildcard:
stream_wildcard_mention_user_ids = info.stream_wildcard_mention_user_ids
stream_wildcard_mention_in_followed_topic_user_ids = (
info.stream_wildcard_mention_in_followed_topic_user_ids
)
else:
wildcard_mention_user_ids = set()
followed_topic_wildcard_mention_user_ids = set()
stream_wildcard_mention_user_ids = set()
stream_wildcard_mention_in_followed_topic_user_ids = set()
"""
Once we have the actual list of mentioned ids from message
@ -615,8 +617,8 @@ def build_message_send_dict(
default_bot_user_ids=info.default_bot_user_ids,
service_bot_tuples=info.service_bot_tuples,
all_bot_user_ids=info.all_bot_user_ids,
wildcard_mention_user_ids=wildcard_mention_user_ids,
followed_topic_wildcard_mention_user_ids=followed_topic_wildcard_mention_user_ids,
stream_wildcard_mention_user_ids=stream_wildcard_mention_user_ids,
stream_wildcard_mention_in_followed_topic_user_ids=stream_wildcard_mention_in_followed_topic_user_ids,
links_for_embed=links_for_embed,
widget_content=widget_content_dict,
limit_unread_user_ids=limit_unread_user_ids,
@ -647,7 +649,7 @@ def create_user_messages(
is_stream_message = message.is_stream_message()
base_flags = 0
if rendering_result.mentions_wildcard:
if rendering_result.mentions_stream_wildcard:
base_flags |= UserMessage.flags.wildcard_mentioned
if message.recipient.type in [Recipient.HUDDLE, Recipient.PERSONAL]:
base_flags |= UserMessage.flags.is_private
@ -912,10 +914,10 @@ def do_send_messages(
pm_mention_email_disabled_user_ids=send_request.pm_mention_email_disabled_user_ids,
stream_push_user_ids=send_request.stream_push_user_ids,
stream_email_user_ids=send_request.stream_email_user_ids,
wildcard_mention_user_ids=send_request.wildcard_mention_user_ids,
stream_wildcard_mention_user_ids=send_request.stream_wildcard_mention_user_ids,
followed_topic_push_user_ids=send_request.followed_topic_push_user_ids,
followed_topic_email_user_ids=send_request.followed_topic_email_user_ids,
followed_topic_wildcard_mention_user_ids=send_request.followed_topic_wildcard_mention_user_ids,
stream_wildcard_mention_in_followed_topic_user_ids=send_request.stream_wildcard_mention_in_followed_topic_user_ids,
muted_sender_user_ids=send_request.muted_sender_user_ids,
all_bot_user_ids=send_request.all_bot_user_ids,
)
@ -940,11 +942,11 @@ def do_send_messages(
),
stream_push_user_ids=list(send_request.stream_push_user_ids),
stream_email_user_ids=list(send_request.stream_email_user_ids),
wildcard_mention_user_ids=list(send_request.wildcard_mention_user_ids),
stream_wildcard_mention_user_ids=list(send_request.stream_wildcard_mention_user_ids),
followed_topic_push_user_ids=list(send_request.followed_topic_push_user_ids),
followed_topic_email_user_ids=list(send_request.followed_topic_email_user_ids),
followed_topic_wildcard_mention_user_ids=list(
send_request.followed_topic_wildcard_mention_user_ids
stream_wildcard_mention_in_followed_topic_user_ids=list(
send_request.stream_wildcard_mention_in_followed_topic_user_ids
),
muted_sender_user_ids=list(send_request.muted_sender_user_ids),
all_bot_user_ids=list(send_request.all_bot_user_ids),
@ -1481,7 +1483,7 @@ def check_message(
if (
stream is not None
and message_send_dict.rendering_result.mentions_wildcard
and message_send_dict.rendering_result.mentions_stream_wildcard
and not wildcard_mention_allowed(sender, stream)
):
raise JsonableError(

14
zerver/lib/email_notifications.py
View File

@ -456,13 +456,14 @@ def do_send_missedmessage_events_reply_in_zulip(
context.update(
mention="mentioned" in unique_triggers
or "wildcard_mentioned" in unique_triggers
or "followed_topic_wildcard_mentioned" in unique_triggers,
or "stream_wildcard_mentioned" in unique_triggers
or "stream_wildcard_mentioned_in_followed_topic" in unique_triggers,
personal_mentioned=personal_mentioned,
wildcard_mentioned="wildcard_mentioned" in unique_triggers,
stream_wildcard_mentioned="stream_wildcard_mentioned" in unique_triggers,
stream_email_notify="stream_email_notify" in unique_triggers,
followed_topic_email_notify="followed_topic_email_notify" in unique_triggers,
followed_topic_wildcard_mentioned="followed_topic_wildcard_mentioned" in unique_triggers,
stream_wildcard_mentioned_in_followed_topic="stream_wildcard_mentioned_in_followed_topic"
in unique_triggers,
mentioned_user_group_name=mentioned_user_group_name,
)
@ -525,8 +526,9 @@ def do_send_missedmessage_events_reply_in_zulip(
m["message"].sender
for m in missed_messages
if m["trigger"] == NotificationTriggers.MENTION
or m["trigger"] == NotificationTriggers.WILDCARD_MENTION
or m["trigger"] == NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION
or m["trigger"] == NotificationTriggers.STREAM_WILDCARD_MENTION
or m["trigger"]
== NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC
}
)
message = missed_messages[0]["message"]

10
zerver/lib/markdown/__init__.py
View File

@ -113,7 +113,7 @@ class LinkInfo(TypedDict):
@dataclass
class MessageRenderingResult:
rendered_content: str
mentions_wildcard: bool
mentions_stream_wildcard: bool
mentions_user_ids: Set[int]
mentions_user_group_ids: Set[int]
alert_words: Set[str]
@ -1776,7 +1776,7 @@ class UserMentionPattern(CompiledInlineProcessor):
silent = m.group("silent") == "_"
db_data: Optional[DbData] = self.zmd.zulip_db_data
if db_data is not None:
wildcard = mention.user_mention_matches_wildcard(name)
stream_wildcard = mention.user_mention_matches_stream_wildcard(name)
# For @**|id** and @**name|id** mention syntaxes.
id_syntax_match = re.match(r"(?P<full_name>.+)?\|(?P<user_id>\d+)$", name)
@ -1795,9 +1795,9 @@ class UserMentionPattern(CompiledInlineProcessor):
# For @**name** syntax.
user = db_data.mention_data.get_user_by_name(name)
if wildcard:
if stream_wildcard:
if not silent:
self.zmd.zulip_rendering_result.mentions_wildcard = True
self.zmd.zulip_rendering_result.mentions_stream_wildcard = True
user_id = "*"
elif user is not None:
assert isinstance(user, FullNameInfo)
@ -2491,7 +2491,7 @@ def do_convert(
# Filters such as UserMentionPattern need a message.
rendering_result: MessageRenderingResult = MessageRenderingResult(
rendered_content="",
mentions_wildcard=False,
mentions_stream_wildcard=False,
mentions_user_ids=set(),
mentions_user_group_ids=set(),
alert_words=set(),

32
zerver/lib/mention.py
View File

@ -18,7 +18,7 @@ USER_GROUP_MENTIONS_RE = re.compile(
rf"{BEFORE_MENTION_ALLOWED_REGEX}@(?P<silent>_?)(\*(?P<match>[^\*]+)\*)"
)
wildcards = frozenset(["all", "everyone", "stream"])
stream_wildcards = frozenset(["all", "everyone", "stream"])
@dataclass
@ -46,13 +46,13 @@ class UserFilter:
@dataclass
class MentionText:
text: Optional[str]
is_wildcard: bool
is_stream_wildcard: bool
@dataclass
class PossibleMentions:
mention_texts: Set[str]
message_has_wildcards: bool
message_has_stream_wildcards: bool
class MentionBackend:
@ -147,29 +147,31 @@ class MentionBackend:
return result
def user_mention_matches_wildcard(mention: str) -> bool:
return mention in wildcards
def user_mention_matches_stream_wildcard(mention: str) -> bool:
return mention in stream_wildcards
def extract_mention_text(m: Match[str]) -> MentionText:
text = m.group("match")
if text in wildcards:
return MentionText(text=None, is_wildcard=True)
return MentionText(text=text, is_wildcard=False)
if text in stream_wildcards:
return MentionText(text=None, is_stream_wildcard=True)
return MentionText(text=text, is_stream_wildcard=False)
def possible_mentions(content: str) -> PossibleMentions:
# mention texts can either be names, or an extended name|id syntax.
texts = set()
message_has_wildcards = False
message_has_stream_wildcards = False
for m in MENTIONS_RE.finditer(content):
mention_text = extract_mention_text(m)
text = mention_text.text
if text:
texts.add(text)
if mention_text.is_wildcard:
message_has_wildcards = True
return PossibleMentions(mention_texts=texts, message_has_wildcards=message_has_wildcards)
if mention_text.is_stream_wildcard:
message_has_stream_wildcards = True
return PossibleMentions(
mention_texts=texts, message_has_stream_wildcards=message_has_stream_wildcards
)
def possible_user_group_mentions(content: str) -> Set[str]:
@ -213,10 +215,10 @@ class MentionData:
self.full_name_info = {row.full_name.lower(): row for row in possible_mentions_info}
self.user_id_info = {row.id: row for row in possible_mentions_info}
self.init_user_group_data(realm_id=realm_id, content=content)
self.has_wildcards = mentions.message_has_wildcards
self.has_stream_wildcards = mentions.message_has_stream_wildcards
def message_has_wildcards(self) -> bool:
return self.has_wildcards
def message_has_stream_wildcards(self) -> bool:
return self.has_stream_wildcards
def init_user_group_data(self, realm_id: int, content: str) -> None:
self.user_group_name_info: Dict[str, UserGroup] = {}

6
zerver/lib/message.py
View File

@ -168,9 +168,9 @@ class SendMessageRequest:
default_bot_user_ids: Set[int]
service_bot_tuples: List[Tuple[int, int]]
all_bot_user_ids: Set[int]
wildcard_mention_user_ids: Set[int]
# IDs of users who have followed the topic the message is being sent to, and have the followed topic wildcard mentions notify setting ON.
followed_topic_wildcard_mention_user_ids: Set[int]
stream_wildcard_mention_user_ids: Set[int]
# IDs of users who have followed the topic the message (having stream wildcard) is being sent to, and have the followed topic wildcard mentions notify setting ON.
stream_wildcard_mention_in_followed_topic_user_ids: Set[int]
links_for_embed: Set[str]
widget_content: Optional[Dict[str, Any]]
submessages: List[Dict[str, Any]] = field(default_factory=list)

66
zerver/lib/notification_data.py
View File

@ -15,14 +15,14 @@ class UserMessageNotificationsData:
pm_push_notify: bool
mention_email_notify: bool
mention_push_notify: bool
wildcard_mention_email_notify: bool
wildcard_mention_push_notify: bool
stream_wildcard_mention_email_notify: bool
stream_wildcard_mention_push_notify: bool
stream_push_notify: bool
stream_email_notify: bool
followed_topic_push_notify: bool
followed_topic_email_notify: bool
followed_topic_wildcard_mention_push_notify: bool
followed_topic_wildcard_mention_email_notify: bool
stream_wildcard_mention_in_followed_topic_push_notify: bool
stream_wildcard_mention_in_followed_topic_email_notify: bool
sender_is_muted: bool
disable_external_notifications: bool
@ -57,10 +57,10 @@ class UserMessageNotificationsData:
pm_mention_email_disabled_user_ids: Set[int],
stream_push_user_ids: Set[int],
stream_email_user_ids: Set[int],
wildcard_mention_user_ids: Set[int],
stream_wildcard_mention_user_ids: Set[int],
followed_topic_push_user_ids: Set[int],
followed_topic_email_user_ids: Set[int],
followed_topic_wildcard_mention_user_ids: Set[int],
stream_wildcard_mention_in_followed_topic_user_ids: Set[int],
muted_sender_user_ids: Set[int],
all_bot_user_ids: Set[int],
) -> "UserMessageNotificationsData":
@ -70,35 +70,35 @@ class UserMessageNotificationsData:
user_id=user_id,
pm_email_notify=False,
mention_email_notify=False,
wildcard_mention_email_notify=False,
stream_wildcard_mention_email_notify=False,
pm_push_notify=False,
mention_push_notify=False,
wildcard_mention_push_notify=False,
stream_wildcard_mention_push_notify=False,
online_push_enabled=False,
stream_push_notify=False,
stream_email_notify=False,
followed_topic_push_notify=False,
followed_topic_email_notify=False,
followed_topic_wildcard_mention_push_notify=False,
followed_topic_wildcard_mention_email_notify=False,
stream_wildcard_mention_in_followed_topic_push_notify=False,
stream_wildcard_mention_in_followed_topic_email_notify=False,
sender_is_muted=False,
disable_external_notifications=False,
)
# `wildcard_mention_user_ids` are those user IDs for whom wildcard mentions should
# obey notification settings of personal mentions. Hence, it isn't an independent
# notification setting and acts as a wrapper.
# `stream_wildcard_mention_user_ids` are those user IDs for whom stream wildcard
# mentions should obey notification settings of personal mentions. Hence, it isn't an
# independent notification setting and acts as a wrapper.
pm_email_notify = user_id not in pm_mention_email_disabled_user_ids and private_message
mention_email_notify = (
user_id not in pm_mention_email_disabled_user_ids and "mentioned" in flags
)
wildcard_mention_email_notify = (
user_id in wildcard_mention_user_ids
stream_wildcard_mention_email_notify = (
user_id in stream_wildcard_mention_user_ids
and user_id not in pm_mention_email_disabled_user_ids
and "wildcard_mentioned" in flags
)
followed_topic_wildcard_mention_email_notify = (
user_id in followed_topic_wildcard_mention_user_ids
stream_wildcard_mention_in_followed_topic_email_notify = (
user_id in stream_wildcard_mention_in_followed_topic_user_ids
and user_id not in pm_mention_email_disabled_user_ids
and "wildcard_mentioned" in flags
)
@ -107,13 +107,13 @@ class UserMessageNotificationsData:
mention_push_notify = (
user_id not in pm_mention_push_disabled_user_ids and "mentioned" in flags
)
wildcard_mention_push_notify = (
user_id in wildcard_mention_user_ids
stream_wildcard_mention_push_notify = (
user_id in stream_wildcard_mention_user_ids
and user_id not in pm_mention_push_disabled_user_ids
and "wildcard_mentioned" in flags
)
followed_topic_wildcard_mention_push_notify = (
user_id in followed_topic_wildcard_mention_user_ids
stream_wildcard_mention_in_followed_topic_push_notify = (
user_id in stream_wildcard_mention_in_followed_topic_user_ids
and user_id not in pm_mention_push_disabled_user_ids
and "wildcard_mentioned" in flags
)
@ -121,17 +121,17 @@ class UserMessageNotificationsData:
user_id=user_id,
pm_email_notify=pm_email_notify,
mention_email_notify=mention_email_notify,
wildcard_mention_email_notify=wildcard_mention_email_notify,
stream_wildcard_mention_email_notify=stream_wildcard_mention_email_notify,
pm_push_notify=pm_push_notify,
mention_push_notify=mention_push_notify,
wildcard_mention_push_notify=wildcard_mention_push_notify,
stream_wildcard_mention_push_notify=stream_wildcard_mention_push_notify,
online_push_enabled=(user_id in online_push_user_ids),
stream_push_notify=(user_id in stream_push_user_ids),
stream_email_notify=(user_id in stream_email_user_ids),
followed_topic_push_notify=(user_id in followed_topic_push_user_ids),
followed_topic_email_notify=(user_id in followed_topic_email_user_ids),
followed_topic_wildcard_mention_push_notify=followed_topic_wildcard_mention_push_notify,
followed_topic_wildcard_mention_email_notify=followed_topic_wildcard_mention_email_notify,
stream_wildcard_mention_in_followed_topic_push_notify=stream_wildcard_mention_in_followed_topic_push_notify,
stream_wildcard_mention_in_followed_topic_email_notify=stream_wildcard_mention_in_followed_topic_email_notify,
sender_is_muted=(user_id in muted_sender_user_ids),
disable_external_notifications=disable_external_notifications,
)
@ -177,10 +177,10 @@ class UserMessageNotificationsData:
return NotificationTriggers.PRIVATE_MESSAGE
elif self.mention_push_notify:
return NotificationTriggers.MENTION
elif self.followed_topic_wildcard_mention_push_notify:
return NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION
elif self.wildcard_mention_push_notify:
return NotificationTriggers.WILDCARD_MENTION
elif self.stream_wildcard_mention_in_followed_topic_push_notify:
return NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC
elif self.stream_wildcard_mention_push_notify:
return NotificationTriggers.STREAM_WILDCARD_MENTION
elif self.followed_topic_push_notify:
return NotificationTriggers.FOLLOWED_TOPIC_PUSH
elif self.stream_push_notify:
@ -205,10 +205,10 @@ class UserMessageNotificationsData:
return NotificationTriggers.PRIVATE_MESSAGE
elif self.mention_email_notify:
return NotificationTriggers.MENTION
elif self.followed_topic_wildcard_mention_email_notify:
return NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION
elif self.wildcard_mention_email_notify:
return NotificationTriggers.WILDCARD_MENTION
elif self.stream_wildcard_mention_in_followed_topic_email_notify:
return NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC
elif self.stream_wildcard_mention_email_notify:
return NotificationTriggers.STREAM_WILDCARD_MENTION
elif self.followed_topic_email_notify:
return NotificationTriggers.FOLLOWED_TOPIC_EMAIL
elif self.stream_email_notify:

8
zerver/lib/push_notifications.py
View File

@ -674,10 +674,10 @@ def get_gcm_alert(
return f"{sender_str} mentioned @{mentioned_user_group_name} in #{display_recipient}"
elif (
message.is_stream_message()
and trigger == NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION
and trigger == NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC
):
return "TODO"
elif message.is_stream_message() and trigger == NotificationTriggers.WILDCARD_MENTION:
elif message.is_stream_message() and trigger == NotificationTriggers.STREAM_WILDCARD_MENTION:
return f"{sender_str} mentioned everyone in #{display_recipient}"
else:
assert message.is_stream_message() and trigger == NotificationTriggers.STREAM_PUSH
@ -842,9 +842,9 @@ def get_apns_alert_subtitle(
)
else:
return _("{full_name} mentioned you:").format(full_name=message.sender.full_name)
elif trigger == NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION:
elif trigger == NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC:
return _("TODO")
elif trigger == NotificationTriggers.WILDCARD_MENTION:
elif trigger == NotificationTriggers.STREAM_WILDCARD_MENTION:
return _("{full_name} mentioned everyone:").format(full_name=message.sender.full_name)
elif message.recipient.type == Recipient.PERSONAL:
return ""

2
zerver/lib/soft_deactivation.py
View File

@ -407,7 +407,7 @@ def soft_reactivate_if_personal_notification(
return to Zulip. As a result, it makes sense to optimistically
soft-reactivate that user, to give them a good return experience.
It's important that we do nothing for wildcard or group mentions,
It's important that we do nothing for stream wildcard or group mentions,
because soft-reactivating an entire realm would be very expensive
(and we can't easily check the group's size). The caller is
responsible for passing a mentioned_user_group_name that is None

4
zerver/lib/stream_subscription.py
View File

@ -306,7 +306,7 @@ def get_subscriptions_for_send_message(
realm_id: int,
stream_id: int,
topic_name: str,
possible_wildcard_mention: bool,
possible_stream_wildcard_mention: bool,
possibly_mentioned_user_ids: AbstractSet[int],
) -> QuerySet[Subscription]:
"""This function optimizes an important use case for large
@ -342,7 +342,7 @@ def get_subscriptions_for_send_message(
include_deactivated_users=False,
)
if possible_wildcard_mention:
if possible_stream_wildcard_mention:
return query
query = query.filter(

16
zerver/lib/test_classes.py
View File

@ -1719,17 +1719,21 @@ Output:
pm_push_notify=kwargs.get("pm_push_notify", False),
mention_email_notify=kwargs.get("mention_email_notify", False),
mention_push_notify=kwargs.get("mention_push_notify", False),
wildcard_mention_email_notify=kwargs.get("wildcard_mention_email_notify", False),
wildcard_mention_push_notify=kwargs.get("wildcard_mention_push_notify", False),
stream_wildcard_mention_email_notify=kwargs.get(
"stream_wildcard_mention_email_notify", False
),
stream_wildcard_mention_push_notify=kwargs.get(
"stream_wildcard_mention_push_notify", False
),
stream_email_notify=kwargs.get("stream_email_notify", False),
stream_push_notify=kwargs.get("stream_push_notify", False),
followed_topic_email_notify=kwargs.get("followed_topic_email_notify", False),
followed_topic_push_notify=kwargs.get("followed_topic_push_notify", False),
followed_topic_wildcard_mention_email_notify=kwargs.get(
"followed_topic_wildcard_mention_email_notify", False
stream_wildcard_mention_in_followed_topic_email_notify=kwargs.get(
"stream_wildcard_mention_in_followed_topic_email_notify", False
),
followed_topic_wildcard_mention_push_notify=kwargs.get(
"followed_topic_wildcard_mention_push_notify", False
stream_wildcard_mention_in_followed_topic_push_notify=kwargs.get(
"stream_wildcard_mention_in_followed_topic_push_notify", False
),
sender_is_muted=kwargs.get("sender_is_muted", False),
disable_external_notifications=kwargs.get("disable_external_notifications", False),

6
zerver/migrations/0331_scheduledmessagenotificationemail.py
View File

@ -26,12 +26,12 @@ class Migration(migrations.Migration):
choices=[
("private_message", "Private message"),
("mentioned", "Mention"),
("wildcard_mentioned", "Wildcard mention"),
("stream_wildcard_mentioned", "Stream wildcard mention"),
("stream_email_notify", "Stream notifications enabled"),
("followed_topic_email_notify", "Followed topic notifications enabled"),
(
"followed_topic_wildcard_mentioned",
"Followed topic wildcard mention",
"stream_wildcard_mentioned_in_followed_topic",
"Stream wildcard mention in followed topic",
),
]
),

36
zerver/migrations/0457_backfill_scheduledmessagenotificationemail_trigger.py Normal file
View File

@ -0,0 +1,36 @@
# Generated by Django 4.2.1 on 2023-06-20 12:07
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
("zerver", "0456_alter_usergroup_can_mention_group"),
]
operations = [
migrations.RunSQL(
"""
UPDATE zerver_scheduledmessagenotificationemail
SET trigger = 'stream_wildcard_mentioned'
WHERE trigger = 'wildcard_mentioned';
""",
reverse_sql="""
UPDATE zerver_scheduledmessagenotificationemail
SET trigger = 'wildcard_mentioned'
WHERE trigger = 'stream_wildcard_mentioned';
""",
),
migrations.RunSQL(
"""
UPDATE zerver_scheduledmessagenotificationemail
SET trigger = 'stream_wildcard_mentioned_in_followed_topic'
WHERE trigger = 'followed_topic_wildcard_mentioned';
""",
reverse_sql="""
UPDATE zerver_scheduledmessagenotificationemail
SET trigger = 'followed_topic_wildcard_mentioned'
WHERE trigger = 'stream_wildcard_mentioned_in_followed_topic';
""",
),
]

11
zerver/models.py
View File

@ -4303,12 +4303,12 @@ class NotificationTriggers:
# "private_message" is for 1:1 direct messages as well as huddles
PRIVATE_MESSAGE = "private_message"
MENTION = "mentioned"
WILDCARD_MENTION = "wildcard_mentioned"
STREAM_WILDCARD_MENTION = "stream_wildcard_mentioned"
STREAM_PUSH = "stream_push_notify"
STREAM_EMAIL = "stream_email_notify"
FOLLOWED_TOPIC_PUSH = "followed_topic_push_notify"
FOLLOWED_TOPIC_EMAIL = "followed_topic_email_notify"
FOLLOWED_TOPIC_WILDCARD_MENTION = "followed_topic_wildcard_mentioned"
STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC = "stream_wildcard_mentioned_in_followed_topic"
class ScheduledMessageNotificationEmail(models.Model):
@ -4324,10 +4324,13 @@ class ScheduledMessageNotificationEmail(models.Model):
EMAIL_NOTIFICATION_TRIGGER_CHOICES = [
(NotificationTriggers.PRIVATE_MESSAGE, "Private message"),
(NotificationTriggers.MENTION, "Mention"),
(NotificationTriggers.WILDCARD_MENTION, "Wildcard mention"),
(NotificationTriggers.STREAM_WILDCARD_MENTION, "Stream wildcard mention"),
(NotificationTriggers.STREAM_EMAIL, "Stream notifications enabled"),
(NotificationTriggers.FOLLOWED_TOPIC_EMAIL, "Followed topic notifications enabled"),
(NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION, "Followed topic wildcard mention"),
(
NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC,
"Stream wildcard mention in followed topic",
),
]
trigger = models.TextField(choices=EMAIL_NOTIFICATION_TRIGGER_CHOICES)

81
zerver/tests/test_email_notifications.py
View File

@ -691,7 +691,7 @@ class TestMissedMessages(ZulipTestCase):
trigger="mentioned",
)
def _extra_context_in_missed_stream_messages_followed_topic_wildcard_mention(
def _extra_context_in_missed_stream_messages_stream_wildcard_mention_in_followed_topic(
self, send_as_user: bool, show_message_content: bool = True
) -> None:
for i in range(1, 6):
@ -729,10 +729,10 @@ class TestMissedMessages(ZulipTestCase):
send_as_user,
show_message_content=show_message_content,
verify_body_does_not_include=verify_body_does_not_include,
trigger="followed_topic_wildcard_mentioned",
trigger="stream_wildcard_mentioned_in_followed_topic",
)
def _extra_context_in_missed_stream_messages_wildcard_mention(
def _extra_context_in_missed_stream_messages_stream_wildcard_mention(
self, send_as_user: bool, show_message_content: bool = True
) -> None:
for i in range(1, 6):
@ -771,7 +771,7 @@ class TestMissedMessages(ZulipTestCase):
send_as_user,
show_message_content=show_message_content,
verify_body_does_not_include=verify_body_does_not_include,
trigger="wildcard_mentioned",
trigger="stream_wildcard_mentioned",
)
def _extra_context_in_missed_stream_messages_email_notify(self, send_as_user: bool) -> None:
@ -1102,7 +1102,7 @@ class TestMissedMessages(ZulipTestCase):
for text in expected_email_include:
self.assertIn(text, self.normalize_string(mail.outbox[0].body))
def test_user_group_over_followed_topic_wildcard_mention_priority(self) -> None:
def test_user_group_over_stream_wildcard_mention_in_followed_topic_priority(self) -> None:
hamlet = self.example_user("hamlet")
cordelia = self.example_user("cordelia")
othello = self.example_user("othello")
@ -1111,7 +1111,7 @@ class TestMissedMessages(ZulipTestCase):
get_realm("zulip"), "hamlet_and_cordelia", [hamlet, cordelia], acting_user=None
)
followed_topic_wildcard_mentioned_message_id = self.send_stream_message(
stream_wildcard_mentioned_in_followed_topic_message_id = self.send_stream_message(
othello, "Denmark", "@**all**"
)
user_group_mentioned_message_id = self.send_stream_message(
@ -1122,8 +1122,8 @@ class TestMissedMessages(ZulipTestCase):
hamlet.id,
[
{
"message_id": followed_topic_wildcard_mentioned_message_id,
"trigger": "followed_topic_wildcard_mentioned",
"message_id": stream_wildcard_mentioned_in_followed_topic_message_id,
"trigger": "stream_wildcard_mentioned_in_followed_topic",
"mentioned_user_group_id": None,
},
{
@ -1142,12 +1142,14 @@ class TestMissedMessages(ZulipTestCase):
for text in expected_email_include:
self.assertIn(text, self.normalize_string(mail.outbox[0].body))
def test_followed_topic_wildcard_over_wildcard_mention_priority(self) -> None:
def test_stream_wildcard_in_followed_topic_over_stream_wildcard_mention_priority(self) -> None:
hamlet = self.example_user("hamlet")
othello = self.example_user("othello")
wildcard_mentioned_message_id = self.send_stream_message(othello, "Denmark", "@**all**")
followed_topic_wildcard_mentioned_message_id = self.send_stream_message(
stream_wildcard_mentioned_message_id = self.send_stream_message(
othello, "Denmark", "@**all**"
)
stream_wildcard_mentioned_in_followed_topic_message_id = self.send_stream_message(
othello, "Denmark", "@**all**"
)
@ -1155,13 +1157,13 @@ class TestMissedMessages(ZulipTestCase):
hamlet.id,
[
{
"message_id": wildcard_mentioned_message_id,
"trigger": "wildcard_mentioned",
"message_id": stream_wildcard_mentioned_message_id,
"trigger": "stream_wildcard_mentioned",
"mentioned_user_group_id": None,
},
{
"message_id": followed_topic_wildcard_mentioned_message_id,
"trigger": "followed_topic_wildcard_mentioned",
"message_id": stream_wildcard_mentioned_in_followed_topic_message_id,
"trigger": "stream_wildcard_mentioned_in_followed_topic",
"mentioned_user_group_id": None,
},
],
@ -1175,12 +1177,14 @@ class TestMissedMessages(ZulipTestCase):
for text in expected_email_include:
self.assertIn(text, self.normalize_string(mail.outbox[0].body))
def test_wildcard_mention_over_followed_topic_notify_priority(self) -> None:
def test_stream_wildcard_mention_over_followed_topic_notify_priority(self) -> None:
hamlet = self.example_user("hamlet")
othello = self.example_user("othello")
followed_topic_mentioned_message_id = self.send_stream_message(othello, "Denmark", "1")
wildcard_mentioned_message_id = self.send_stream_message(othello, "Denmark", "@**all**")
stream_wildcard_mentioned_message_id = self.send_stream_message(
othello, "Denmark", "@**all**"
)
handle_missedmessage_emails(
hamlet.id,
@ -1191,8 +1195,8 @@ class TestMissedMessages(ZulipTestCase):
"mentioned_user_group_id": None,
},
{
"message_id": wildcard_mentioned_message_id,
"trigger": "wildcard_mentioned",
"message_id": stream_wildcard_mentioned_message_id,
"trigger": "stream_wildcard_mentioned",
"mentioned_user_group_id": None,
},
],
@ -1322,11 +1326,11 @@ class TestMissedMessages(ZulipTestCase):
)
self._extra_context_in_missed_stream_messages_mention(False, show_message_content=False)
mail.outbox = []
self._extra_context_in_missed_stream_messages_followed_topic_wildcard_mention(
self._extra_context_in_missed_stream_messages_stream_wildcard_mention_in_followed_topic(
False, show_message_content=False
)
mail.outbox = []
self._extra_context_in_missed_stream_messages_wildcard_mention(
self._extra_context_in_missed_stream_messages_stream_wildcard_mention(
False, show_message_content=False
)
mail.outbox = []
@ -1344,20 +1348,26 @@ class TestMissedMessages(ZulipTestCase):
self._extra_context_in_missed_stream_messages_mention(False)
@override_settings(SEND_MISSED_MESSAGE_EMAILS_AS_USER=True)
def test_extra_context_in_missed_stream_messages_as_user_followed_topic_wildcard(
def test_extra_context_in_missed_stream_messages_as_user_stream_wildcard_in_followed_topic(
self,
) -> None:
self._extra_context_in_missed_stream_messages_followed_topic_wildcard_mention(True)
self._extra_context_in_missed_stream_messages_stream_wildcard_mention_in_followed_topic(
True
)
def test_extra_context_in_missed_stream_messages_followed_topic_wildcard(self) -> None:
self._extra_context_in_missed_stream_messages_followed_topic_wildcard_mention(False)
def test_extra_context_in_missed_stream_messages_stream_wildcard_in_followed_topic(
self,
) -> None:
self._extra_context_in_missed_stream_messages_stream_wildcard_mention_in_followed_topic(
False
)
@override_settings(SEND_MISSED_MESSAGE_EMAILS_AS_USER=True)
def test_extra_context_in_missed_stream_messages_as_user_wildcard(self) -> None:
self._extra_context_in_missed_stream_messages_wildcard_mention(True)
def test_extra_context_in_missed_stream_messages_as_user_stream_wildcard(self) -> None:
self._extra_context_in_missed_stream_messages_stream_wildcard_mention(True)
def test_extra_context_in_missed_stream_messages_wildcard(self) -> None:
self._extra_context_in_missed_stream_messages_wildcard_mention(False)
def test_extra_context_in_missed_stream_messages_stream_wildcard(self) -> None:
self._extra_context_in_missed_stream_messages_stream_wildcard_mention(False)
@override_settings(SEND_MISSED_MESSAGE_EMAILS_AS_USER=True)
def test_extra_context_in_missed_stream_messages_as_user_two_senders(self) -> None:
@ -1945,7 +1955,7 @@ class TestMissedMessages(ZulipTestCase):
[{"message_id": personal_message_id, "trigger": "private_message"}],
)
# Followed Topic wildcard mention should NOT soft reactivate the user
# Stream wildcard mention in followed topic should NOT soft reactivate the user
with self.soft_deactivate_and_check_long_term_idle(hamlet, expected=True):
mention = "@**all**"
stream_mentioned_message_id = self.send_stream_message(othello, "Denmark", mention)
@ -1954,19 +1964,24 @@ class TestMissedMessages(ZulipTestCase):
[
{
"message_id": stream_mentioned_message_id,
"trigger": "followed_topic_wildcard_mentioned",
"trigger": "stream_wildcard_mentioned_in_followed_topic",
}
],
)
# Wildcard mention should NOT soft reactivate the user
# Stream Wildcard mention should NOT soft reactivate the user
with self.soft_deactivate_and_check_long_term_idle(hamlet, expected=True):
# Soft reactivate the user by sending a personal message
mention = "@**all**"
stream_mentioned_message_id = self.send_stream_message(othello, "Denmark", mention)
handle_missedmessage_emails(
hamlet.id,
[{"message_id": stream_mentioned_message_id, "trigger": "wildcard_mentioned"}],
[
{
"message_id": stream_mentioned_message_id,
"trigger": "stream_wildcard_mentioned",
}
],
)
# Group mention should NOT soft reactivate the user

60
zerver/tests/test_event_queue.py
View File

@ -298,8 +298,8 @@ class MissedMessageHookTest(ZulipTestCase):
already_notified={"email_notified": True, "push_notified": False},
)
def test_wildcard_mention(self) -> None:
# By default, wildcard mentions should send notifications, just like regular mentions
def test_stream_wildcard_mention(self) -> None:
# By default, stream wildcard mentions should send notifications, just like regular mentions
msg_id = self.send_stream_message(self.iago, "Denmark", content="@**all** what's up?")
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(self.user_profile.id, self.client_descriptor, True)
@ -310,13 +310,13 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
wildcard_mention_email_notify=True,
wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
already_notified={"email_notified": True, "push_notified": True},
)
def test_wildcard_mention_in_muted_stream(self) -> None:
# Wildcard mentions in muted streams don't notify.
def test_stream_wildcard_mention_in_muted_stream(self) -> None:
# stream wildcard mentions in muted streams don't notify.
self.change_subscription_properties({"is_muted": True})
msg_id = self.send_stream_message(self.iago, "Denmark", content="@**all** what's up?")
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
@ -326,15 +326,15 @@ class MissedMessageHookTest(ZulipTestCase):
self.assert_maybe_enqueue_notifications_call_args(
args_dict=args_dict,
wildcard_mention_email_notify=False,
wildcard_mention_push_notify=False,
stream_wildcard_mention_email_notify=False,
stream_wildcard_mention_push_notify=False,
message_id=msg_id,
user_id=self.user_profile.id,
already_notified={"email_notified": False, "push_notified": False},
)
def test_wildcard_mention_in_muted_topic(self) -> None:
# Wildcard mentions in muted streams don't notify.
def test_stream_wildcard_mention_in_muted_topic(self) -> None:
# stream wildcard mentions in muted topics don't notify.
do_set_user_topic_visibility_policy(
self.user_profile,
get_stream("Denmark", self.user_profile.realm),
@ -351,8 +351,8 @@ class MissedMessageHookTest(ZulipTestCase):
self.assert_maybe_enqueue_notifications_call_args(
args_dict=args_dict,
wildcard_mention_email_notify=False,
wildcard_mention_push_notify=False,
stream_wildcard_mention_email_notify=False,
stream_wildcard_mention_push_notify=False,
message_id=msg_id,
user_id=self.user_profile.id,
already_notified={"email_notified": False, "push_notified": False},
@ -373,12 +373,14 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
wildcard_mention_email_notify=False,
wildcard_mention_push_notify=False,
stream_wildcard_mention_email_notify=False,
stream_wildcard_mention_push_notify=False,
already_notified={"email_notified": False, "push_notified": False},
)
def test_wildcard_mentions_notify_stream_specific_setting(self) -> None:
def test_wildcard_mentions_notify_stream_specific_setting(
self,
) -> None:
# If wildcard_mentions_notify=True for a stream and False for a user, we treat the user
# as mentioned for that stream.
do_change_user_setting(
@ -395,8 +397,8 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
wildcard_mention_email_notify=True,
wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
already_notified={"email_notified": True, "push_notified": True},
)
@ -423,8 +425,8 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
wildcard_mention_email_notify=False,
wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=False,
stream_wildcard_mention_push_notify=True,
already_notified={"email_notified": False, "push_notified": True},
)
@ -444,8 +446,8 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
wildcard_mention_email_notify=False,
wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=False,
stream_wildcard_mention_push_notify=True,
already_notified={"email_notified": False, "push_notified": True},
)
@ -840,7 +842,7 @@ class MissedMessageHookTest(ZulipTestCase):
already_notified={"email_notified": True, "push_notified": False},
)
def test_followed_topic_wildcard_mention_notify(self) -> None:
def test_stream_wildcard_mention_in_followed_topic_notify(self) -> None:
do_change_user_setting(
self.user_profile, "wildcard_mentions_notify", False, acting_user=None
)
@ -870,13 +872,13 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
followed_topic_wildcard_mention_email_notify=True,
followed_topic_wildcard_mention_push_notify=True,
stream_wildcard_mention_in_followed_topic_email_notify=True,
stream_wildcard_mention_in_followed_topic_push_notify=True,
already_notified={"email_notified": True, "push_notified": True},
)
def test_followed_topic_wildcard_mention_in_muted_stream(self) -> None:
# By default, wildcard mentions in a followed topic with muted stream DO notify.
def test_stream_wildcard_mention_in_followed_topic_muted_stream(self) -> None:
# By default, stream wildcard mentions in a followed topic with muted stream DO notify.
do_change_user_setting(
self.user_profile, "wildcard_mentions_notify", False, acting_user=None
)
@ -906,8 +908,8 @@ class MissedMessageHookTest(ZulipTestCase):
args_dict=args_dict,
message_id=msg_id,
user_id=self.user_profile.id,
followed_topic_wildcard_mention_email_notify=True,
followed_topic_wildcard_mention_push_notify=True,
stream_wildcard_mention_in_followed_topic_email_notify=True,
stream_wildcard_mention_in_followed_topic_push_notify=True,
already_notified={"email_notified": True, "push_notified": True},
)
@ -1407,7 +1409,7 @@ class SchemaMigrationsTests(ZulipTestCase):
online_push_user_ids=[hamlet.id, cordelia.id],
stream_push_user_ids=[cordelia.id],
stream_email_user_ids=[hamlet.id],
wildcard_mention_user_ids=[cordelia.id],
stream_wildcard_mention_user_ids=[cordelia.id],
muted_sender_user_ids=[],
)
with mock.patch("zerver.tornado.event_queue.process_message_event") as m:

2
zerver/tests/test_events.py
View File

@ -456,7 +456,7 @@ class NormalActionsTest(BaseAction):
lambda: self.send_stream_message(self.example_user("cordelia"), "Verona", content),
)
def test_wildcard_mentioned_send_message_events(self) -> None:
def test_stream_wildcard_mentioned_send_message_events(self) -> None:
for i in range(3):
content = "mentioning... @**all** hello " + str(i)
self.verify_action(

30
zerver/tests/test_markdown.py
View File

@ -277,10 +277,10 @@ class MarkdownMiscTest(ZulipTestCase):
assert user is not None
self.assertEqual(user.full_name, hamlet.full_name)
self.assertFalse(mention_data.message_has_wildcards())
self.assertFalse(mention_data.message_has_stream_wildcards())
content = "@**King Hamlet** @**Cordelia, lear's daughter** @**all**"
mention_data = MentionData(mention_backend, content)
self.assertTrue(mention_data.message_has_wildcards())
self.assertTrue(mention_data.message_has_stream_wildcards())
def test_invalid_katex_path(self) -> None:
with self.settings(DEPLOY_ROOT="/nonexistent"):
@ -1817,7 +1817,7 @@ class MarkdownTest(ZulipTestCase):
rendering_result.rendered_content,
'<p><span class="user-mention" data-user-id="*">@all</span> test</p>',
)
self.assertTrue(rendering_result.mentions_wildcard)
self.assertTrue(rendering_result.mentions_stream_wildcard)
def test_mention_everyone(self) -> None:
user_profile = self.example_user("othello")
@ -1829,7 +1829,7 @@ class MarkdownTest(ZulipTestCase):
rendering_result.rendered_content,
'<p><span class="user-mention" data-user-id="*">@everyone</span> test</p>',
)
self.assertTrue(rendering_result.mentions_wildcard)
self.assertTrue(rendering_result.mentions_stream_wildcard)
def test_mention_stream(self) -> None:
user_profile = self.example_user("othello")
@ -1841,7 +1841,7 @@ class MarkdownTest(ZulipTestCase):
rendering_result.rendered_content,
'<p><span class="user-mention" data-user-id="*">@stream</span> test</p>',
)
self.assertTrue(rendering_result.mentions_wildcard)
self.assertTrue(rendering_result.mentions_stream_wildcard)
def test_mention_at_wildcard(self) -> None:
user_profile = self.example_user("othello")
@ -1850,7 +1850,7 @@ class MarkdownTest(ZulipTestCase):
content = "@all test"
rendering_result = render_markdown(msg, content)
self.assertEqual(rendering_result.rendered_content, "<p>@all test</p>")
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
self.assertEqual(rendering_result.mentions_user_ids, set())
def test_mention_at_everyone(self) -> None:
@ -1860,7 +1860,7 @@ class MarkdownTest(ZulipTestCase):
content = "@everyone test"
rendering_result = render_markdown(msg, content)
self.assertEqual(rendering_result.rendered_content, "<p>@everyone test</p>")
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
self.assertEqual(rendering_result.mentions_user_ids, set())
def test_mention_word_starting_with_at_wildcard(self) -> None:
@ -1870,7 +1870,7 @@ class MarkdownTest(ZulipTestCase):
content = "test @alleycat.com test"
rendering_result = render_markdown(msg, content)
self.assertEqual(rendering_result.rendered_content, "<p>test @alleycat.com test</p>")
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
self.assertEqual(rendering_result.mentions_user_ids, set())
def test_mention_at_normal_user(self) -> None:
@ -1880,7 +1880,7 @@ class MarkdownTest(ZulipTestCase):
content = "@aaron test"
rendering_result = render_markdown(msg, content)
self.assertEqual(rendering_result.rendered_content, "<p>@aaron test</p>")
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
self.assertEqual(rendering_result.mentions_user_ids, set())
def test_mention_single(self) -> None:
@ -1965,7 +1965,7 @@ class MarkdownTest(ZulipTestCase):
rendering_result.rendered_content,
f'<p><span class="user-mention silent" data-user-id="*">{wildcard}</span></p>',
)
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
def test_mention_invalid_followed_by_valid(self) -> None:
sender_user_profile = self.example_user("othello")
@ -2030,10 +2030,14 @@ class MarkdownTest(ZulipTestCase):
self.assertEqual(rendering_result.mentions_user_ids, set())
def test_possible_mentions(self) -> None:
def assert_mentions(content: str, names: Set[str], has_wildcards: bool = False) -> None:
def assert_mentions(
content: str, names: Set[str], has_stream_wildcards: bool = False
) -> None:
self.assertEqual(
possible_mentions(content),
PossibleMentions(mention_texts=names, message_has_wildcards=has_wildcards),
PossibleMentions(
mention_texts=names, message_has_stream_wildcards=has_stream_wildcards
),
)
aaron = self.example_user("aaron")
@ -2127,7 +2131,7 @@ class MarkdownTest(ZulipTestCase):
)
rendering_result = render_markdown(message, content)
self.assertEqual(rendering_result.rendered_content, expected)
self.assertFalse(rendering_result.mentions_wildcard)
self.assertFalse(rendering_result.mentions_stream_wildcard)
wildcards = ["all", "everyone", "stream"]
for wildcard in wildcards:

20
zerver/tests/test_message_edit.py
View File

@ -2039,7 +2039,9 @@ class EditMessageTest(EditMessageTestCase):
)
@mock.patch("zerver.actions.message_edit.send_event")
def test_followed_topic_wildcard_mention(self, mock_send_event: mock.MagicMock) -> None:
def test_stream_wildcard_mention_in_followed_topic(
self, mock_send_event: mock.MagicMock
) -> None:
stream_name = "Macbeth"
hamlet = self.example_user("hamlet")
cordelia = self.example_user("cordelia")
@ -2072,14 +2074,16 @@ class EditMessageTest(EditMessageTestCase):
self.assert_json_success(result)
# Extract the send_event call where event type is 'update_message'.
# Here we assert 'followed_topic_wildcard_mention_user_ids'
# Here we assert 'stream_wildcard_mention_in_followed_topic_user_ids'
# has been set properly.
called = False
for call_args in mock_send_event.call_args_list:
(arg_realm, arg_event, arg_notified_users) = call_args[0]
if arg_event["type"] == "update_message":
self.assertEqual(arg_event["type"], "update_message")
self.assertEqual(arg_event["followed_topic_wildcard_mention_user_ids"], [hamlet.id])
self.assertEqual(
arg_event["stream_wildcard_mention_in_followed_topic_user_ids"], [hamlet.id]
)
self.assertEqual(
sorted(arg_notified_users, key=itemgetter("id")), users_to_be_notified
)
@ -2087,7 +2091,7 @@ class EditMessageTest(EditMessageTestCase):
self.assertTrue(called)
@mock.patch("zerver.actions.message_edit.send_event")
def test_wildcard_mention(self, mock_send_event: mock.MagicMock) -> None:
def test_stream_wildcard_mention(self, mock_send_event: mock.MagicMock) -> None:
stream_name = "Macbeth"
hamlet = self.example_user("hamlet")
cordelia = self.example_user("cordelia")
@ -2113,20 +2117,22 @@ class EditMessageTest(EditMessageTestCase):
self.assert_json_success(result)
# Extract the send_event call where event type is 'update_message'.
# Here we assert wildcard_mention_user_ids has been set properly.
# Here we assert 'stream_wildcard_mention_user_ids' has been set properly.
called = False
for call_args in mock_send_event.call_args_list:
(arg_realm, arg_event, arg_notified_users) = call_args[0]
if arg_event["type"] == "update_message":
self.assertEqual(arg_event["type"], "update_message")
self.assertEqual(arg_event["wildcard_mention_user_ids"], [cordelia.id, hamlet.id])
self.assertEqual(
arg_event["stream_wildcard_mention_user_ids"], [cordelia.id, hamlet.id]
)
self.assertEqual(
sorted(arg_notified_users, key=itemgetter("id")), users_to_be_notified
)
called = True
self.assertTrue(called)
def test_wildcard_mention_restrictions_when_editing(self) -> None:
def test_stream_wildcard_mention_restrictions_when_editing(self) -> None:
cordelia = self.example_user("cordelia")
shiva = self.example_user("shiva")
self.login("cordelia")

12
zerver/tests/test_message_edit_notifications.py
View File

@ -398,7 +398,7 @@ class EditMessageSideEffectsTest(ZulipTestCase):
# actual content of these messages.)
self.assert_length(info["queue_messages"], 2)
def test_updates_with_followed_topic_wildcard_mention(self) -> None:
def test_updates_with_stream_wildcard_mention_in_followed_topic(self) -> None:
cordelia = self.example_user("cordelia")
hamlet = self.example_user("hamlet")
self.subscribe(cordelia, "Scotland")
@ -435,8 +435,8 @@ class EditMessageSideEffectsTest(ZulipTestCase):
user_id=cordelia.id,
acting_user_id=hamlet.id,
message_id=message_id,
followed_topic_wildcard_mention_email_notify=True,
followed_topic_wildcard_mention_push_notify=True,
stream_wildcard_mention_in_followed_topic_email_notify=True,
stream_wildcard_mention_in_followed_topic_push_notify=True,
already_notified={},
)
self.assertEqual(info["enqueue_kwargs"], expected_enqueue_kwargs)
@ -444,7 +444,7 @@ class EditMessageSideEffectsTest(ZulipTestCase):
# messages will get enqueued.
self.assert_length(info["queue_messages"], 2)
def test_updates_with_wildcard_mention(self) -> None:
def test_updates_with_stream_wildcard_mention(self) -> None:
cordelia = self.example_user("cordelia")
hamlet = self.example_user("hamlet")
@ -466,8 +466,8 @@ class EditMessageSideEffectsTest(ZulipTestCase):
user_id=cordelia.id,
acting_user_id=hamlet.id,
message_id=message_id,
wildcard_mention_email_notify=True,
wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
already_notified={},
)
self.assertEqual(info["enqueue_kwargs"], expected_enqueue_kwargs)

40
zerver/tests/test_message_send.py
View File

@ -1624,11 +1624,11 @@ class StreamMessagesTest(ZulipTestCase):
self.assertEqual(user_message.message.content, content)
self.assertTrue(user_message.flags.mentioned)
def send_and_verify_wildcard_mention_message(
def send_and_verify_stream_wildcard_mention_message(
self, sender_name: str, test_fails: bool = False, sub_count: int = 16
) -> None:
sender = self.example_user(sender_name)
content = "@**all** test wildcard mention"
content = "@**all** test stream wildcard mention"
with mock.patch("zerver.lib.message.num_subscribers_for_stream_id", return_value=sub_count):
if not test_fails:
msg_id = self.send_stream_message(sender, "test_stream", content)
@ -1642,7 +1642,7 @@ class StreamMessagesTest(ZulipTestCase):
):
self.send_stream_message(sender, "test_stream", content)
def test_wildcard_mention_restrictions(self) -> None:
def test_stream_wildcard_mention_restrictions(self) -> None:
cordelia = self.example_user("cordelia")
iago = self.example_user("iago")
polonius = self.example_user("polonius")
@ -1661,7 +1661,7 @@ class StreamMessagesTest(ZulipTestCase):
Realm.WILDCARD_MENTION_POLICY_EVERYONE,
acting_user=None,
)
self.send_and_verify_wildcard_mention_message("polonius")
self.send_and_verify_stream_wildcard_mention_message("polonius")
do_set_realm_property(
realm,
@ -1669,10 +1669,10 @@ class StreamMessagesTest(ZulipTestCase):
Realm.WILDCARD_MENTION_POLICY_MEMBERS,
acting_user=None,
)
self.send_and_verify_wildcard_mention_message("polonius", test_fails=True)
self.send_and_verify_stream_wildcard_mention_message("polonius", test_fails=True)
# There is no restriction on small streams.
self.send_and_verify_wildcard_mention_message("polonius", sub_count=10)
self.send_and_verify_wildcard_mention_message("cordelia")
self.send_and_verify_stream_wildcard_mention_message("polonius", sub_count=10)
self.send_and_verify_stream_wildcard_mention_message("cordelia")
do_set_realm_property(
realm,
@ -1687,15 +1687,15 @@ class StreamMessagesTest(ZulipTestCase):
shiva.save()
cordelia.date_joined = timezone_now()
cordelia.save()
self.send_and_verify_wildcard_mention_message("cordelia", test_fails=True)
self.send_and_verify_wildcard_mention_message("cordelia", sub_count=10)
self.send_and_verify_stream_wildcard_mention_message("cordelia", test_fails=True)
self.send_and_verify_stream_wildcard_mention_message("cordelia", sub_count=10)
# Administrators and moderators can use wildcard mentions even if they are new.
self.send_and_verify_wildcard_mention_message("iago")
self.send_and_verify_wildcard_mention_message("shiva")
self.send_and_verify_stream_wildcard_mention_message("iago")
self.send_and_verify_stream_wildcard_mention_message("shiva")
cordelia.date_joined = timezone_now() - datetime.timedelta(days=11)
cordelia.save()
self.send_and_verify_wildcard_mention_message("cordelia")
self.send_and_verify_stream_wildcard_mention_message("cordelia")
do_set_realm_property(
realm,
@ -1703,25 +1703,25 @@ class StreamMessagesTest(ZulipTestCase):
Realm.WILDCARD_MENTION_POLICY_MODERATORS,
acting_user=None,
)
self.send_and_verify_wildcard_mention_message("cordelia", test_fails=True)
self.send_and_verify_wildcard_mention_message("cordelia", sub_count=10)
self.send_and_verify_wildcard_mention_message("shiva")
self.send_and_verify_stream_wildcard_mention_message("cordelia", test_fails=True)
self.send_and_verify_stream_wildcard_mention_message("cordelia", sub_count=10)
self.send_and_verify_stream_wildcard_mention_message("shiva")
cordelia.date_joined = timezone_now()
cordelia.save()
do_set_realm_property(
realm, "wildcard_mention_policy", Realm.WILDCARD_MENTION_POLICY_ADMINS, acting_user=None
)
self.send_and_verify_wildcard_mention_message("shiva", test_fails=True)
self.send_and_verify_stream_wildcard_mention_message("shiva", test_fails=True)
# There is no restriction on small streams.
self.send_and_verify_wildcard_mention_message("shiva", sub_count=10)
self.send_and_verify_wildcard_mention_message("iago")
self.send_and_verify_stream_wildcard_mention_message("shiva", sub_count=10)
self.send_and_verify_stream_wildcard_mention_message("iago")
do_set_realm_property(
realm, "wildcard_mention_policy", Realm.WILDCARD_MENTION_POLICY_NOBODY, acting_user=None
)
self.send_and_verify_wildcard_mention_message("iago", test_fails=True)
self.send_and_verify_wildcard_mention_message("iago", sub_count=10)
self.send_and_verify_stream_wildcard_mention_message("iago", test_fails=True)
self.send_and_verify_stream_wildcard_mention_message("iago", sub_count=10)
def test_invalid_wildcard_mention_policy(self) -> None:
cordelia = self.example_user("cordelia")

52
zerver/tests/test_notification_data.py
View File

@ -40,13 +40,13 @@ class TestNotificationData(ZulipTestCase):
)
self.assertTrue(user_data.is_push_notifiable(acting_user_id=acting_user_id, idle=True))
# Wildcard mention
# Stream Wildcard mention
user_data = self.create_user_notifications_data_object(
user_id=user_id, wildcard_mention_push_notify=True
user_id=user_id, stream_wildcard_mention_push_notify=True
)
self.assertEqual(
user_data.get_push_notification_trigger(acting_user_id=acting_user_id, idle=True),
"wildcard_mentioned",
"stream_wildcard_mentioned",
)
self.assertTrue(user_data.is_push_notifiable(acting_user_id=acting_user_id, idle=True))
@ -70,13 +70,13 @@ class TestNotificationData(ZulipTestCase):
)
self.assertTrue(user_data.is_push_notifiable(acting_user_id=acting_user_id, idle=True))
# Followed Topic wildcard mention
# Stream wildcard mention in followed topic
user_data = self.create_user_notifications_data_object(
user_id=user_id, followed_topic_wildcard_mention_push_notify=True
user_id=user_id, stream_wildcard_mention_in_followed_topic_push_notify=True
)
self.assertEqual(
user_data.get_push_notification_trigger(acting_user_id=acting_user_id, idle=True),
"followed_topic_wildcard_mentioned",
"stream_wildcard_mentioned_in_followed_topic",
)
self.assertTrue(user_data.is_push_notifiable(acting_user_id=acting_user_id, idle=True))
@ -108,8 +108,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
)
self.assertEqual(
user_data.get_push_notification_trigger(acting_user_id=acting_user_id, idle=True),
@ -124,8 +124,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
)
self.assertEqual(
user_data.get_push_notification_trigger(acting_user_id=acting_user_id, idle=True),
@ -140,8 +140,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
disable_external_notifications=True,
)
self.assertEqual(
@ -182,13 +182,13 @@ class TestNotificationData(ZulipTestCase):
)
self.assertTrue(user_data.is_email_notifiable(acting_user_id=acting_user_id, idle=True))
# Wildcard mention
# Stream Wildcard mention
user_data = self.create_user_notifications_data_object(
user_id=user_id, wildcard_mention_email_notify=True
user_id=user_id, stream_wildcard_mention_email_notify=True
)
self.assertEqual(
user_data.get_email_notification_trigger(acting_user_id=acting_user_id, idle=True),
"wildcard_mentioned",
"stream_wildcard_mentioned",
)
self.assertTrue(user_data.is_email_notifiable(acting_user_id=acting_user_id, idle=True))
@ -212,13 +212,13 @@ class TestNotificationData(ZulipTestCase):
)
self.assertTrue(user_data.is_email_notifiable(acting_user_id=acting_user_id, idle=True))
# Followed Topic wildcard mention
# Stream wildcard mention in followed topic
user_data = self.create_user_notifications_data_object(
user_id=user_id, followed_topic_wildcard_mention_email_notify=True
user_id=user_id, stream_wildcard_mention_in_followed_topic_email_notify=True
)
self.assertEqual(
user_data.get_email_notification_trigger(acting_user_id=acting_user_id, idle=True),
"followed_topic_wildcard_mentioned",
"stream_wildcard_mentioned_in_followed_topic",
)
self.assertTrue(user_data.is_email_notifiable(acting_user_id=acting_user_id, idle=True))
@ -241,8 +241,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
)
self.assertEqual(
user_data.get_email_notification_trigger(acting_user_id=acting_user_id, idle=True),
@ -257,8 +257,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
)
self.assertEqual(
user_data.get_email_notification_trigger(acting_user_id=acting_user_id, idle=True),
@ -273,8 +273,8 @@ class TestNotificationData(ZulipTestCase):
pm_email_notify=True,
mention_push_notify=True,
mention_email_notify=True,
wildcard_mention_push_notify=True,
wildcard_mention_email_notify=True,
stream_wildcard_mention_push_notify=True,
stream_wildcard_mention_email_notify=True,
disable_external_notifications=True,
)
self.assertEqual(
@ -306,10 +306,10 @@ class TestNotificationData(ZulipTestCase):
muted_sender_user_ids=set(),
stream_email_user_ids=set(),
stream_push_user_ids=set(),
wildcard_mention_user_ids=set(),
stream_wildcard_mention_user_ids=set(),
followed_topic_email_user_ids=set(),
followed_topic_push_user_ids=set(),
followed_topic_wildcard_mention_user_ids=set(),
stream_wildcard_mention_in_followed_topic_user_ids=set(),
)
self.assertEqual(user_data.is_notifiable(acting_user_id=1000, idle=True), notifiable)

26
zerver/tests/test_push_notifications.py
View File

@ -1675,7 +1675,7 @@ class HandlePushNotificationTest(PushNotificationTest):
{"message_id": personal_message_id, "trigger": "private_message"},
)
# Followed Topic wildcard mention should NOT soft reactivate the user
# Stream wildcard mention in followed topic should NOT soft reactivate the user
with self.soft_deactivate_and_check_long_term_idle(self.user_profile, expected=True):
mention = "@**all**"
stream_mentioned_message_id = self.send_stream_message(othello, "Denmark", mention)
@ -1683,18 +1683,18 @@ class HandlePushNotificationTest(PushNotificationTest):
self.user_profile.id,
{
"message_id": stream_mentioned_message_id,
"trigger": "followed_topic_wildcard_mentioned",
"trigger": "stream_wildcard_mentioned_in_followed_topic",
},
)
# Wildcard mention should NOT soft reactivate the user
# Stream Wildcard mention should NOT soft reactivate the user
with self.soft_deactivate_and_check_long_term_idle(self.user_profile, expected=True):
# Soft reactivate the user by sending a personal message
mention = "@**all**"
stream_mentioned_message_id = self.send_stream_message(othello, "Denmark", mention)
handle_push_notification(
self.user_profile.id,
{"message_id": stream_mentioned_message_id, "trigger": "wildcard_mentioned"},
{"message_id": stream_mentioned_message_id, "trigger": "stream_wildcard_mentioned"},
)
# Group mention should NOT soft reactivate the user
@ -2070,12 +2070,12 @@ class TestGetAPNsPayload(PushNotificationTest):
}
self.assertDictEqual(payload, expected)
def test_get_message_payload_apns_followed_topic_wildcard_mention(self) -> None:
def test_get_message_payload_apns_stream_wildcard_mention_in_followed_topic(self) -> None:
user_profile = self.example_user("othello")
stream = Stream.objects.filter(name="Verona").get()
message = self.get_message(Recipient.STREAM, stream.id, stream.realm_id)
payload = get_message_payload_apns(
user_profile, message, NotificationTriggers.FOLLOWED_TOPIC_WILDCARD_MENTION
user_profile, message, NotificationTriggers.STREAM_WILDCARD_MENTION_IN_FOLLOWED_TOPIC
)
expected = {
"alert": {
@ -2108,7 +2108,7 @@ class TestGetAPNsPayload(PushNotificationTest):
stream = Stream.objects.filter(name="Verona").get()
message = self.get_message(Recipient.STREAM, stream.id, stream.realm_id)
payload = get_message_payload_apns(
user_profile, message, NotificationTriggers.WILDCARD_MENTION
user_profile, message, NotificationTriggers.STREAM_WILDCARD_MENTION
)
expected = {
"alert": {
@ -2243,12 +2243,14 @@ class TestGetGCMPayload(PushNotificationTest):
mentioned_user_group_name="mobile_team",
)
def test_get_message_payload_gcm_followed_topic_wildcard_mention(self) -> None:
self._test_get_message_payload_gcm_mentions("followed_topic_wildcard_mentioned", "TODO")
def test_get_message_payload_gcm_wildcard_mention(self) -> None:
def test_get_message_payload_gcm_stream_wildcard_mention_in_followed_topic(self) -> None:
self._test_get_message_payload_gcm_mentions(
"wildcard_mentioned", "King Hamlet mentioned everyone in #Verona"
"stream_wildcard_mentioned_in_followed_topic", "TODO"
)
def test_get_message_payload_gcm_stream_wildcard_mention(self) -> None:
self._test_get_message_payload_gcm_mentions(
"stream_wildcard_mentioned", "King Hamlet mentioned everyone in #Verona"
)
def test_get_message_payload_gcm_private_message(self) -> None:

16
zerver/tests/test_soft_deactivation.py
View File

@ -623,7 +623,7 @@ class SoftDeactivationMessageTest(ZulipTestCase):
def assert_num_possible_users(
expected_count: int,
*,
possible_wildcard_mention: bool = False,
possible_stream_wildcard_mention: bool = False,
possibly_mentioned_user_ids: AbstractSet[int] = set(),
) -> None:
self.assertEqual(
@ -632,7 +632,7 @@ class SoftDeactivationMessageTest(ZulipTestCase):
realm_id=realm_id,
stream_id=stream_id,
topic_name=topic_name,
possible_wildcard_mention=possible_wildcard_mention,
possible_stream_wildcard_mention=possible_stream_wildcard_mention,
possibly_mentioned_user_ids=possibly_mentioned_user_ids,
)
),
@ -642,12 +642,12 @@ class SoftDeactivationMessageTest(ZulipTestCase):
def assert_stream_message_sent_to_idle_user(
content: str,
*,
possible_wildcard_mention: bool = False,
possible_stream_wildcard_mention: bool = False,
possibly_mentioned_user_ids: AbstractSet[int] = set(),
) -> None:
assert_num_possible_users(
expected_count=3,
possible_wildcard_mention=possible_wildcard_mention,
possible_stream_wildcard_mention=possible_stream_wildcard_mention,
possibly_mentioned_user_ids=possibly_mentioned_user_ids,
)
general_user_msg_count = len(get_user_messages(cordelia))
@ -756,15 +756,15 @@ class SoftDeactivationMessageTest(ZulipTestCase):
assert_stream_message_not_sent_to_idle_user("Test @**Cordelia, Lear's daughter** mention")
# Test UserMessage row is created while user is deactivated if
# there is a wildcard mention such as @all or @everyone
# there is a stream wildcard mention such as @all or @everyone
assert_stream_message_sent_to_idle_user(
"Test @**all** mention", possible_wildcard_mention=True
"Test @**all** mention", possible_stream_wildcard_mention=True
)
assert_stream_message_sent_to_idle_user(
"Test @**everyone** mention", possible_wildcard_mention=True
"Test @**everyone** mention", possible_stream_wildcard_mention=True
)
assert_stream_message_sent_to_idle_user(
"Test @**stream** mention", possible_wildcard_mention=True
"Test @**stream** mention", possible_stream_wildcard_mention=True
)
assert_stream_message_not_sent_to_idle_user("Test @**bogus** mention")

40
zerver/tests/test_users.py
View File

@ -1755,7 +1755,7 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=False,
possible_stream_wildcard_mention=False,
)
all_user_ids = {hamlet.id, cordelia.id, othello.id}
@ -1767,10 +1767,10 @@ class RecipientInfoTest(ZulipTestCase):
pm_mention_push_disabled_user_ids=set(),
stream_push_user_ids=set(),
stream_email_user_ids=set(),
wildcard_mention_user_ids=set(),
stream_wildcard_mention_user_ids=set(),
followed_topic_push_user_ids=set(),
followed_topic_email_user_ids=set(),
followed_topic_wildcard_mention_user_ids=set(),
stream_wildcard_mention_in_followed_topic_user_ids=set(),
muted_sender_user_ids=set(),
um_eligible_user_ids=all_user_ids,
long_term_idle_user_ids=set(),
@ -1789,7 +1789,7 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=False,
possible_stream_wildcard_mention=False,
)
self.assertEqual(info.pm_mention_email_disabled_user_ids, {hamlet.id})
self.assertEqual(info.pm_mention_push_disabled_user_ids, {hamlet.id})
@ -1806,19 +1806,19 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=False,
possible_stream_wildcard_mention=False,
)
self.assertEqual(info.stream_push_user_ids, {hamlet.id})
self.assertEqual(info.wildcard_mention_user_ids, set())
self.assertEqual(info.stream_wildcard_mention_user_ids, set())
info = get_recipient_info(
realm_id=realm.id,
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=True,
possible_stream_wildcard_mention=True,
)
self.assertEqual(info.wildcard_mention_user_ids, {hamlet.id, othello.id})
self.assertEqual(info.stream_wildcard_mention_user_ids, {hamlet.id, othello.id})
sub = get_subscription(stream_name, hamlet)
sub.push_notifications = False
@ -1884,22 +1884,22 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=False,
possible_stream_wildcard_mention=False,
)
self.assertEqual(info.stream_push_user_ids, set())
self.assertEqual(info.wildcard_mention_user_ids, set())
self.assertEqual(info.stream_wildcard_mention_user_ids, set())
info = get_recipient_info(
realm_id=realm.id,
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=True,
possible_stream_wildcard_mention=True,
)
self.assertEqual(info.stream_push_user_ids, set())
# Since Hamlet has muted the stream and Cordelia has disabled
# wildcard notifications, it should just be Othello here.
self.assertEqual(info.wildcard_mention_user_ids, {othello.id})
self.assertEqual(info.stream_wildcard_mention_user_ids, {othello.id})
# If Hamlet mutes Cordelia, he should be in `muted_sender_user_ids` for a message
# sent by Cordelia.
@ -1909,7 +1909,7 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=cordelia.id,
stream_topic=stream_topic,
possible_wildcard_mention=True,
possible_stream_wildcard_mention=True,
)
self.assertTrue(hamlet.id in info.muted_sender_user_ids)
@ -1922,11 +1922,11 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=True,
possible_stream_wildcard_mention=True,
)
self.assertEqual(info.stream_push_user_ids, set())
# Verify that stream-level wildcard_mentions_notify=False works correctly.
self.assertEqual(info.wildcard_mention_user_ids, set())
self.assertEqual(info.stream_wildcard_mention_user_ids, set())
# Verify that True works as expected as well
sub = get_subscription(stream_name, othello)
@ -1938,10 +1938,10 @@ class RecipientInfoTest(ZulipTestCase):
recipient=recipient,
sender_id=hamlet.id,
stream_topic=stream_topic,
possible_wildcard_mention=True,
possible_stream_wildcard_mention=True,
)
self.assertEqual(info.stream_push_user_ids, set())
self.assertEqual(info.wildcard_mention_user_ids, {othello.id})
self.assertEqual(info.stream_wildcard_mention_user_ids, {othello.id})
# Add a service bot.
service_bot = do_create_user(
@ -2005,7 +2005,7 @@ class RecipientInfoTest(ZulipTestCase):
)
self.assertEqual(info.followed_topic_email_user_ids, {hamlet.id})
self.assertEqual(info.followed_topic_push_user_ids, {hamlet.id})
self.assertEqual(info.followed_topic_wildcard_mention_user_ids, {hamlet.id})
self.assertEqual(info.stream_wildcard_mention_in_followed_topic_user_ids, {hamlet.id})
# Omit Hamlet from followed_topic_email_user_ids
do_change_user_setting(
@ -2021,7 +2021,7 @@ class RecipientInfoTest(ZulipTestCase):
False,
acting_user=None,
)
# Omit Hamlet from followed_topic_wildcard_mention_user_ids
# Omit Hamlet from stream_wildcard_mention_in_followed_topic_user_ids
do_change_user_setting(
hamlet,
"enable_followed_topic_wildcard_mentions_notify",
@ -2037,7 +2037,7 @@ class RecipientInfoTest(ZulipTestCase):
)
self.assertEqual(info.followed_topic_email_user_ids, set())
self.assertEqual(info.followed_topic_push_user_ids, set())
self.assertEqual(info.followed_topic_wildcard_mention_user_ids, set())
self.assertEqual(info.stream_wildcard_mention_in_followed_topic_user_ids, set())
def test_get_recipient_info_invalid_recipient_type(self) -> None:
hamlet = self.example_user("hamlet")

82
zerver/tornado/event_queue.py
View File

@ -774,6 +774,30 @@ def missedmessage_hook(
internal_data = event.get("internal_data", {})
sender_id = event["message"]["sender_id"]
# TODO/compatibility: Translation code for the rename of
# `wildcard_mention_push_notify` to `stream_wildcard_mention_push_notify`.
# Remove this when one can no longer directly upgrade from 7.x to main.
stream_wildcard_mention_push_notify = False
if "stream_wildcard_mention_push_notify" in internal_data:
stream_wildcard_mention_push_notify = internal_data.get(
"stream_wildcard_mention_push_notify"
)
elif "wildcard_mention_push_notify" in internal_data:
stream_wildcard_mention_push_notify = internal_data.get("wildcard_mention_push_notify")
# TODO/compatibility: Translation code for the rename of
# `wildcard_mention_email_notify` to `stream_wildcard_mention_email_notify`.
# Remove this when one can no longer directly upgrade from 7.x to main.
stream_wildcard_mention_email_notify = False
if "stream_wildcard_mention_email_notify" in internal_data:
stream_wildcard_mention_email_notify = internal_data.get(
"stream_wildcard_mention_email_notify"
)
elif "wildcard_mention_email_notify" in internal_data:
stream_wildcard_mention_email_notify = internal_data.get(
"wildcard_mention_email_notify"
)
user_notifications_data = UserMessageNotificationsData(
user_id=user_profile_id,
sender_is_muted=internal_data.get("sender_is_muted", False),
@ -781,17 +805,17 @@ def missedmessage_hook(
pm_email_notify=internal_data.get("pm_email_notify", False),
mention_push_notify=internal_data.get("mention_push_notify", False),
mention_email_notify=internal_data.get("mention_email_notify", False),
wildcard_mention_push_notify=internal_data.get("wildcard_mention_push_notify", False),
wildcard_mention_email_notify=internal_data.get("wildcard_mention_email_notify", False),
stream_wildcard_mention_push_notify=stream_wildcard_mention_push_notify,
stream_wildcard_mention_email_notify=stream_wildcard_mention_email_notify,
stream_push_notify=internal_data.get("stream_push_notify", False),
stream_email_notify=internal_data.get("stream_email_notify", False),
followed_topic_push_notify=internal_data.get("followed_topic_push_notify", False),
followed_topic_email_notify=internal_data.get("followed_topic_email_notify", False),
followed_topic_wildcard_mention_push_notify=internal_data.get(
"followed_topic_wildcard_mention_push_notify", False
stream_wildcard_mention_in_followed_topic_push_notify=internal_data.get(
"stream_wildcard_mention_in_followed_topic_push_notify", False
),
followed_topic_wildcard_mention_email_notify=internal_data.get(
"followed_topic_wildcard_mention_email_notify", False
stream_wildcard_mention_in_followed_topic_email_notify=internal_data.get(
"stream_wildcard_mention_in_followed_topic_email_notify", False
),
# Since one is by definition idle, we don't need to check online_push_enabled
online_push_enabled=False,
@ -945,11 +969,22 @@ def process_message_event(
)
stream_push_user_ids = set(event_template.get("stream_push_user_ids", []))
stream_email_user_ids = set(event_template.get("stream_email_user_ids", []))
wildcard_mention_user_ids = set(event_template.get("wildcard_mention_user_ids", []))
# TODO/compatibility: Translation code for the rename of
# `wildcard_mention_user_ids` to `stream_wildcard_mention_user_ids`.
# Remove this when one can no longer directly upgrade from 7.x to main.
stream_wildcard_mention_user_ids = set()
if "stream_wildcard_mention_user_ids" in event_template:
stream_wildcard_mention_user_ids = set(
event_template.get("stream_wildcard_mention_user_ids", [])
)
elif "wildcard_mention_user_ids" in event_template:
stream_wildcard_mention_user_ids = set(event_template.get("wildcard_mention_user_ids", []))
followed_topic_push_user_ids = set(event_template.get("followed_topic_push_user_ids", []))
followed_topic_email_user_ids = set(event_template.get("followed_topic_email_user_ids", []))
followed_topic_wildcard_mention_user_ids = set(
event_template.get("followed_topic_wildcard_mention_user_ids", [])
stream_wildcard_mention_in_followed_topic_user_ids = set(
event_template.get("stream_wildcard_mention_in_followed_topic_user_ids", [])
)
muted_sender_user_ids = set(event_template.get("muted_sender_user_ids", []))
all_bot_user_ids = set(event_template.get("all_bot_user_ids", []))
@ -1000,10 +1035,10 @@ def process_message_event(
pm_mention_email_disabled_user_ids=pm_mention_email_disabled_user_ids,
stream_push_user_ids=stream_push_user_ids,
stream_email_user_ids=stream_email_user_ids,
wildcard_mention_user_ids=wildcard_mention_user_ids,
stream_wildcard_mention_user_ids=stream_wildcard_mention_user_ids,
followed_topic_push_user_ids=followed_topic_push_user_ids,
followed_topic_email_user_ids=followed_topic_email_user_ids,
followed_topic_wildcard_mention_user_ids=followed_topic_wildcard_mention_user_ids,
stream_wildcard_mention_in_followed_topic_user_ids=stream_wildcard_mention_in_followed_topic_user_ids,
muted_sender_user_ids=muted_sender_user_ids,
all_bot_user_ids=all_bot_user_ids,
)
@ -1154,11 +1189,22 @@ def process_message_update_event(
)
stream_push_user_ids = set(event_template.pop("stream_push_user_ids", []))
stream_email_user_ids = set(event_template.pop("stream_email_user_ids", []))
wildcard_mention_user_ids = set(event_template.pop("wildcard_mention_user_ids", []))
# TODO/compatibility: Translation code for the rename of
# `wildcard_mention_user_ids` to `stream_wildcard_mention_user_ids`.
# Remove this when one can no longer directly upgrade from 7.x to main.
stream_wildcard_mention_user_ids = set()
if "stream_wildcard_mention_user_ids" in event_template:
stream_wildcard_mention_user_ids = set(
event_template.pop("stream_wildcard_mention_user_ids")
)
elif "wildcard_mention_user_ids" in event_template:
stream_wildcard_mention_user_ids = set(event_template.pop("wildcard_mention_user_ids"))
followed_topic_push_user_ids = set(event_template.pop("followed_topic_push_user_ids", []))
followed_topic_email_user_ids = set(event_template.pop("followed_topic_email_user_ids", []))
followed_topic_wildcard_mention_user_ids = set(
event_template.pop("followed_topic_wildcard_mention_user_ids", [])
stream_wildcard_mention_in_followed_topic_user_ids = set(
event_template.pop("stream_wildcard_mention_in_followed_topic_user_ids", [])
)
muted_sender_user_ids = set(event_template.pop("muted_sender_user_ids", []))
all_bot_user_ids = set(event_template.pop("all_bot_user_ids", []))
@ -1219,10 +1265,10 @@ def process_message_update_event(
pm_mention_email_disabled_user_ids=pm_mention_email_disabled_user_ids,
stream_push_user_ids=stream_push_user_ids,
stream_email_user_ids=stream_email_user_ids,
wildcard_mention_user_ids=wildcard_mention_user_ids,
stream_wildcard_mention_user_ids=stream_wildcard_mention_user_ids,
followed_topic_push_user_ids=followed_topic_push_user_ids,
followed_topic_email_user_ids=followed_topic_email_user_ids,
followed_topic_wildcard_mention_user_ids=followed_topic_wildcard_mention_user_ids,
stream_wildcard_mention_in_followed_topic_user_ids=stream_wildcard_mention_in_followed_topic_user_ids,
muted_sender_user_ids=muted_sender_user_ids,
all_bot_user_ids=all_bot_user_ids,
)
@ -1343,7 +1389,7 @@ def reformat_legacy_send_message_event(
modern_event["online_push_user_ids"] = []
modern_event["stream_push_user_ids"] = []
modern_event["stream_email_user_ids"] = []
modern_event["wildcard_mention_user_ids"] = []
modern_event["stream_wildcard_mention_user_ids"] = []
modern_event["muted_sender_user_ids"] = []
for user in user_dicts:
@ -1354,7 +1400,7 @@ def reformat_legacy_send_message_event(
if user.pop("stream_email_notify", False):
modern_event["stream_email_user_ids"].append(user_id)
if user.pop("wildcard_mention_notify", False):
modern_event["wildcard_mention_user_ids"].append(user_id)
modern_event["stream_wildcard_mention_user_ids"].append(user_id)
if user.pop("sender_is_muted", False):
modern_event["muted_sender_user_ids"].append(user_id)