mirror of
https://github.com/zulip/zulip.git
synced 2025-11-03 21:43:21 +00:00
8dc82f97c7
We don't have our linter checking test files due to ultra-long strings that are often present in test output that we verify. But it's worth at least cleaning out all the ultra-long def lines.
435 lines
14 KiB
Python
435 lines
14 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
from typing import Any, Dict, Generator, Mapping, Text, 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,
|
|
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: Text) -> 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: Text) -> 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: Text,
|
|
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,
|
|
stream_push_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,
|
|
stream_push_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,
|
|
stream_push_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,
|
|
stream_push_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,
|
|
stream_push_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)
|