mirror of
https://github.com/zulip/zulip.git
synced 2025-11-06 06:53:25 +00:00
0ed0bb6828
Historically, Zulip's implementation of wildcard mentions never triggered either email or push notifications, instead being limited to desktop notifications and the "mentions" counter. We fix this just by plumbing the "wildcard_mentioned" flag through our system. Implements much of https://github.com/zulip/zulip/issues/6040#issuecomment-510157264. We're also now ready to seriously work on #3750.
444 lines
15 KiB
Python
444 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from typing import Any, Dict, Mapping, Union
|
|
|
|
import mock
|
|
|
|
from django.utils.timezone import now as timezone_now
|
|
|
|
from zerver.lib.actions import (
|
|
get_client,
|
|
)
|
|
|
|
from zerver.lib.test_classes import (
|
|
ZulipTestCase,
|
|
)
|
|
|
|
from zerver.models import (
|
|
get_stream_recipient,
|
|
Subscription,
|
|
UserPresence,
|
|
)
|
|
|
|
from zerver.tornado.event_queue import (
|
|
maybe_enqueue_notifications,
|
|
)
|
|
|
|
class EditMessageSideEffectsTest(ZulipTestCase):
|
|
def _assert_update_does_not_notify_anybody(self, message_id: int, content: str) -> None:
|
|
url = '/json/messages/' + str(message_id)
|
|
|
|
request = dict(
|
|
message_id=message_id,
|
|
content=content,
|
|
)
|
|
|
|
with mock.patch('zerver.tornado.event_queue.maybe_enqueue_notifications') as m:
|
|
result = self.client_patch(url, request)
|
|
|
|
self.assert_json_success(result)
|
|
self.assertFalse(m.called)
|
|
|
|
def test_updates_with_pm_mention(self) -> None:
|
|
hamlet = self.example_user('hamlet')
|
|
cordelia = self.example_user('cordelia')
|
|
|
|
self.login(hamlet.email)
|
|
|
|
message_id = self.send_personal_message(
|
|
hamlet.email,
|
|
cordelia.email,
|
|
content='no mention'
|
|
)
|
|
|
|
self._assert_update_does_not_notify_anybody(
|
|
message_id=message_id,
|
|
content='now we mention @**Cordelia Lear**',
|
|
)
|
|
|
|
def _login_and_send_original_stream_message(self, content: str) -> int:
|
|
'''
|
|
Note our conventions here:
|
|
|
|
Hamlet is our logged in user (and sender).
|
|
Cordelia is the receiver we care about.
|
|
Scotland is the stream we send messages to.
|
|
'''
|
|
hamlet = self.example_user('hamlet')
|
|
cordelia = self.example_user('cordelia')
|
|
|
|
self.login(hamlet.email)
|
|
self.subscribe(hamlet, 'Scotland')
|
|
self.subscribe(cordelia, 'Scotland')
|
|
|
|
message_id = self.send_stream_message(
|
|
hamlet.email,
|
|
'Scotland',
|
|
content=content,
|
|
)
|
|
|
|
return message_id
|
|
|
|
def _get_queued_data_for_message_update(self, message_id: int, content: str,
|
|
expect_short_circuit: bool=False) -> Dict[str, Any]:
|
|
'''
|
|
This function updates a message with a post to
|
|
/json/messages/(message_id).
|
|
|
|
By using mocks, we are able to capture two pieces of data:
|
|
|
|
enqueue_kwargs: These are the arguments passed in to
|
|
maybe_enqueue_notifications.
|
|
|
|
queue_messages: These are the messages that
|
|
maybe_enqueue_notifications actually
|
|
puts on the queue.
|
|
|
|
Using this helper allows you to construct a test that goes
|
|
pretty deep into the missed-messages codepath, without actually
|
|
queuing the final messages.
|
|
'''
|
|
url = '/json/messages/' + str(message_id)
|
|
|
|
request = dict(
|
|
message_id=message_id,
|
|
content=content,
|
|
)
|
|
|
|
with mock.patch('zerver.tornado.event_queue.maybe_enqueue_notifications') as m:
|
|
result = self.client_patch(url, request)
|
|
|
|
cordelia = self.example_user('cordelia')
|
|
cordelia_calls = [
|
|
call_args
|
|
for call_args in m.call_args_list
|
|
if call_args[1]['user_profile_id'] == cordelia.id
|
|
]
|
|
|
|
if expect_short_circuit:
|
|
self.assertEqual(len(cordelia_calls), 0)
|
|
return {}
|
|
|
|
# Normally we expect maybe_enqueue_notifications to be
|
|
# called for Cordelia, so continue on.
|
|
self.assertEqual(len(cordelia_calls), 1)
|
|
enqueue_kwargs = cordelia_calls[0][1]
|
|
|
|
queue_messages = []
|
|
|
|
def fake_publish(queue_name: str,
|
|
event: Union[Mapping[str, Any], str],
|
|
*args: Any) -> None:
|
|
queue_messages.append(dict(
|
|
queue_name=queue_name,
|
|
event=event,
|
|
))
|
|
|
|
with mock.patch('zerver.tornado.event_queue.queue_json_publish') as m:
|
|
m.side_effect = fake_publish
|
|
maybe_enqueue_notifications(**enqueue_kwargs)
|
|
|
|
self.assert_json_success(result)
|
|
|
|
return dict(
|
|
enqueue_kwargs=enqueue_kwargs,
|
|
queue_messages=queue_messages
|
|
)
|
|
|
|
def test_updates_with_stream_mention(self) -> None:
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention',
|
|
)
|
|
|
|
info = self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='now we mention @**Cordelia Lear**',
|
|
)
|
|
|
|
cordelia = self.example_user('cordelia')
|
|
expected_enqueue_kwargs = dict(
|
|
user_profile_id=cordelia.id,
|
|
message_id=message_id,
|
|
private_message=False,
|
|
mentioned=True,
|
|
wildcard_mentioned=False,
|
|
stream_push_notify=False,
|
|
stream_email_notify=False,
|
|
stream_name='Scotland',
|
|
always_push_notify=False,
|
|
idle=True,
|
|
already_notified={},
|
|
)
|
|
|
|
self.assertEqual(info['enqueue_kwargs'], expected_enqueue_kwargs)
|
|
|
|
queue_messages = info['queue_messages']
|
|
|
|
self.assertEqual(len(queue_messages), 2)
|
|
|
|
self.assertEqual(queue_messages[0]['queue_name'], 'missedmessage_mobile_notifications')
|
|
mobile_event = queue_messages[0]['event']
|
|
|
|
self.assertEqual(mobile_event['user_profile_id'], cordelia.id)
|
|
self.assertEqual(mobile_event['trigger'], 'mentioned')
|
|
|
|
self.assertEqual(queue_messages[1]['queue_name'], 'missedmessage_emails')
|
|
email_event = queue_messages[1]['event']
|
|
|
|
self.assertEqual(email_event['user_profile_id'], cordelia.id)
|
|
self.assertEqual(email_event['trigger'], 'mentioned')
|
|
|
|
def test_second_mention_is_ignored(self) -> None:
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='hello @**Cordelia Lear**'
|
|
)
|
|
|
|
self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='re-mention @**Cordelia Lear**',
|
|
expect_short_circuit=True,
|
|
)
|
|
|
|
def _turn_on_stream_push_for_cordelia(self) -> None:
|
|
'''
|
|
conventions:
|
|
Cordelia is the message receiver we care about.
|
|
Scotland is our stream.
|
|
'''
|
|
cordelia = self.example_user('cordelia')
|
|
stream = self.subscribe(cordelia, 'Scotland')
|
|
recipient = get_stream_recipient(stream.id)
|
|
cordelia_subscription = Subscription.objects.get(
|
|
user_profile_id=cordelia.id,
|
|
recipient=recipient,
|
|
)
|
|
cordelia_subscription.push_notifications = True
|
|
cordelia_subscription.save()
|
|
|
|
def test_updates_with_stream_push_notify(self) -> None:
|
|
self._turn_on_stream_push_for_cordelia()
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
# Even though Cordelia configured this stream for pushes,
|
|
# we short-ciruit the logic, assuming the original message
|
|
# also did a push.
|
|
self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='nothing special about updated message',
|
|
expect_short_circuit=True,
|
|
)
|
|
|
|
def _cordelia_connected_to_zulip(self) -> Any:
|
|
'''
|
|
Right now the easiest way to make Cordelia look
|
|
connected to Zulip is to mock the function below.
|
|
|
|
This is a bit blunt, as it affects other users too,
|
|
but we only really look at Cordelia's data, anyway.
|
|
'''
|
|
return mock.patch(
|
|
'zerver.tornado.event_queue.receiver_is_off_zulip',
|
|
return_value=False
|
|
)
|
|
|
|
def test_stream_push_notify_for_sorta_present_user(self) -> None:
|
|
self._turn_on_stream_push_for_cordelia()
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
# Simulate Cordelia still has an actively polling client, but
|
|
# the lack of presence info should still mark her as offline.
|
|
#
|
|
# Despite Cordelia being offline, we still short circuit
|
|
# offline notifications due to the her stream push setting.
|
|
with self._cordelia_connected_to_zulip():
|
|
self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='nothing special about updated message',
|
|
expect_short_circuit=True,
|
|
)
|
|
|
|
def _make_cordelia_present_on_web(self) -> None:
|
|
cordelia = self.example_user('cordelia')
|
|
UserPresence.objects.create(
|
|
user_profile_id=cordelia.id,
|
|
status=UserPresence.ACTIVE,
|
|
client=get_client('web'),
|
|
timestamp=timezone_now(),
|
|
)
|
|
|
|
def test_stream_push_notify_for_fully_present_user(self) -> None:
|
|
self._turn_on_stream_push_for_cordelia()
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
self._make_cordelia_present_on_web()
|
|
|
|
# Simulate Cordelia is FULLY present, not just in term of
|
|
# browser activity, but also in terms of her client descriptors.
|
|
with self._cordelia_connected_to_zulip():
|
|
self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='nothing special about updated message',
|
|
expect_short_circuit=True,
|
|
)
|
|
|
|
def test_always_push_notify_for_fully_present_mentioned_user(self) -> None:
|
|
cordelia = self.example_user('cordelia')
|
|
cordelia.enable_online_push_notifications = True
|
|
cordelia.save()
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
self._make_cordelia_present_on_web()
|
|
|
|
# Simulate Cordelia is FULLY present, not just in term of
|
|
# browser activity, but also in terms of her client descriptors.
|
|
with self._cordelia_connected_to_zulip():
|
|
info = self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='newly mention @**Cordelia Lear**',
|
|
)
|
|
|
|
expected_enqueue_kwargs = dict(
|
|
user_profile_id=cordelia.id,
|
|
message_id=message_id,
|
|
private_message=False,
|
|
mentioned=True,
|
|
wildcard_mentioned=False,
|
|
stream_push_notify=False,
|
|
stream_email_notify=False,
|
|
stream_name='Scotland',
|
|
always_push_notify=True,
|
|
idle=False,
|
|
already_notified={},
|
|
)
|
|
|
|
self.assertEqual(info['enqueue_kwargs'], expected_enqueue_kwargs)
|
|
|
|
queue_messages = info['queue_messages']
|
|
|
|
self.assertEqual(len(queue_messages), 1)
|
|
|
|
def test_always_push_notify_for_fully_present_boring_user(self) -> None:
|
|
cordelia = self.example_user('cordelia')
|
|
cordelia.enable_online_push_notifications = True
|
|
cordelia.save()
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
self._make_cordelia_present_on_web()
|
|
|
|
# Simulate Cordelia is FULLY present, not just in term of
|
|
# browser activity, but also in terms of her client descriptors.
|
|
with self._cordelia_connected_to_zulip():
|
|
info = self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='nothing special about updated message',
|
|
)
|
|
|
|
expected_enqueue_kwargs = dict(
|
|
user_profile_id=cordelia.id,
|
|
message_id=message_id,
|
|
private_message=False,
|
|
mentioned=False,
|
|
wildcard_mentioned=False,
|
|
stream_push_notify=False,
|
|
stream_email_notify=False,
|
|
stream_name='Scotland',
|
|
always_push_notify=True,
|
|
idle=False,
|
|
already_notified={},
|
|
)
|
|
|
|
self.assertEqual(info['enqueue_kwargs'], expected_enqueue_kwargs)
|
|
|
|
queue_messages = info['queue_messages']
|
|
|
|
# Even though Cordelia has enable_online_push_notifications set
|
|
# to True, we don't send her any offline notifications, since she
|
|
# was not mentioned.
|
|
self.assertEqual(len(queue_messages), 0)
|
|
|
|
def test_updates_with_stream_mention_of_sorta_present_user(self) -> None:
|
|
cordelia = self.example_user('cordelia')
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
# We will simulate that the user still has a an active client,
|
|
# but they don't have UserPresence rows, so we will still
|
|
# send offline notifications.
|
|
with self._cordelia_connected_to_zulip():
|
|
info = self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='now we mention @**Cordelia Lear**',
|
|
)
|
|
|
|
expected_enqueue_kwargs = dict(
|
|
user_profile_id=cordelia.id,
|
|
message_id=message_id,
|
|
private_message=False,
|
|
mentioned=True,
|
|
wildcard_mentioned=False,
|
|
stream_push_notify=False,
|
|
stream_email_notify=False,
|
|
stream_name='Scotland',
|
|
always_push_notify=False,
|
|
idle=True,
|
|
already_notified={},
|
|
)
|
|
self.assertEqual(info['enqueue_kwargs'], expected_enqueue_kwargs)
|
|
|
|
# She will get messages enqueued. (Other tests drill down on the
|
|
# actual content of these messages.)
|
|
self.assertEqual(len(info['queue_messages']), 2)
|
|
|
|
def test_updates_with_stream_mention_of_fully_present_user(self) -> None:
|
|
cordelia = self.example_user('cordelia')
|
|
|
|
message_id = self._login_and_send_original_stream_message(
|
|
content='no mention'
|
|
)
|
|
|
|
self._make_cordelia_present_on_web()
|
|
|
|
# Simulate Cordelia is FULLY present, not just in term of
|
|
# browser activity, but also in terms of her client descriptors.
|
|
with self._cordelia_connected_to_zulip():
|
|
info = self._get_queued_data_for_message_update(
|
|
message_id=message_id,
|
|
content='now we mention @**Cordelia Lear**',
|
|
)
|
|
|
|
expected_enqueue_kwargs = dict(
|
|
user_profile_id=cordelia.id,
|
|
message_id=message_id,
|
|
private_message=False,
|
|
mentioned=True,
|
|
wildcard_mentioned=False,
|
|
stream_push_notify=False,
|
|
stream_email_notify=False,
|
|
stream_name='Scotland',
|
|
always_push_notify=False,
|
|
idle=False,
|
|
already_notified={},
|
|
)
|
|
self.assertEqual(info['enqueue_kwargs'], expected_enqueue_kwargs)
|
|
|
|
# Because Cordelia is FULLY present, we don't need to send any offline
|
|
# push notifications or missed message emails.
|
|
self.assertEqual(len(info['queue_messages']), 0)
|