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

831 lines
33 KiB
Python
Raw Normal View History

minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
import time
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
from typing import Any, Callable, Collection, Dict, List
python: Sort imports with isort. Fixes #2665. Regenerated by tabbott with `lint --fix` after a rebase and change in parameters. Note from tabbott: In a few cases, this converts technical debt in the form of unsorted imports into different technical debt in the form of our largest files having very long, ugly import sequences at the start. I expect this change will increase pressure for us to split those files, which isn't a bad thing. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-06-11 00:54:34 +02:00
from unittest import mock
tests: Add a test suite for maybe_enqueue_notifications. This ensures that as we expand the logic for under what circumstances email and push notifications should be sent, we can be confident about this code path always doing the right thing.
2017-09-27 20:27:04 +02:00
python: Replace ujson with orjson. Fixes #6507. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-08-07 01:09:47 +02:00
import orjson
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
from django.http import HttpRequest, HttpResponse
tests: Add a test suite for maybe_enqueue_notifications. This ensures that as we expand the logic for under what circumstances email and push notifications should be sent, we can be confident about this code path always doing the right thing.
2017-09-27 20:27:04 +02:00
python: Sort imports with isort. Fixes #2665. Regenerated by tabbott with `lint --fix` after a rebase and change in parameters. Note from tabbott: In a few cases, this converts technical debt in the form of unsorted imports into different technical debt in the form of our largest files having very long, ugly import sequences at the start. I expect this change will increase pressure for us to split those files, which isn't a bad thing. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-06-11 00:54:34 +02:00
from zerver.lib.actions import do_change_subscription_property, do_mute_topic
tests: Add a test suite for maybe_enqueue_notifications. This ensures that as we expand the logic for under what circumstances email and push notifications should be sent, we can be confident about this code path always doing the right thing.
2017-09-27 20:27:04 +02:00
from zerver.lib.test_classes import ZulipTestCase
refactor: Integrate POSTRequestMock into HostRequestMock. Minimized code duplication by integrating POSTRequestMock into HostRequestMock and then updating the required files with HostRequestMock. Fixes part of #1211.
2021-02-07 21:34:01 +01:00
from zerver.lib.test_helpers import HostRequestMock, mock_queue_publish
test_event_queue: Make subscription management code readable. This test refactor makes the subscription/stream settings changes use standard APIs and thus be easier to follow (and more robust to subtle re-fetching bugs). This is a follow-up to #9181.
2018-08-08 21:39:19 +02:00
from zerver.models import Recipient, Stream, Subscription, UserProfile, get_stream
python: Sort imports with isort. Fixes #2665. Regenerated by tabbott with `lint --fix` after a rebase and change in parameters. Note from tabbott: In a few cases, this converts technical debt in the form of unsorted imports into different technical debt in the form of our largest files having very long, ugly import sequences at the start. I expect this change will increase pressure for us to split those files, which isn't a bad thing. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-06-11 00:54:34 +02:00
from zerver.tornado.event_queue import (
ClientDescriptor,
allocate_client_descriptor,
get_client_descriptor,
maybe_enqueue_notifications,
missedmessage_hook,
persistent_queue_filename,
event_queue: Translation code for user data migration. This is separate from the next commit for ease of testing. To verify that the compatibility code works correctly, all message send and event_queue tests from our test suite should pass on just this commit.
2021-06-18 19:30:57 +02:00
process_notification,
python: Sort imports with isort. Fixes #2665. Regenerated by tabbott with `lint --fix` after a rebase and change in parameters. Note from tabbott: In a few cases, this converts technical debt in the form of unsorted imports into different technical debt in the form of our largest files having very long, ugly import sequences at the start. I expect this change will increase pressure for us to split those files, which isn't a bad thing. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-06-11 00:54:34 +02:00
)
from zerver.tornado.views import cleanup_event_queue, get_events
tests: Add a test suite for maybe_enqueue_notifications. This ensures that as we expand the logic for under what circumstances email and push notifications should be sent, we can be confident about this code path always doing the right thing.
2017-09-27 20:27:04 +02:00
class MissedMessageNotificationsTest(ZulipTestCase):
"""Tests the logic for when missed-message notifications
should be triggered, based on user settings"""
python: Whitespace fixes from autopep8. Generated by autopep8, with the setup.cfg configuration from #14532. I’m not sure why pycodestyle didn’t already flag these. Signed-off-by: Anders Kaseorg <anders@zulipchat.com>
2020-04-22 01:45:30 +02:00
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
def test_maybe_enqueue_notifications(self) -> None:
# We've already tested the "when to send notifications" logic as part of the
# notification_data module.
# This test is for verifying whether `maybe_enqueue_notifications` returns the
# `already_notified` data correctly.
params = self.get_maybe_enqueue_notifications_parameters(
message_id=1, user_id=1, sender_id=2
)
test_event_queue: Extract common data setup in `check_will_notify`. The `message_id` and `user_profile_id` values don't really matter for our testing here, so we might as well set these dummy values in the main function.
2021-06-08 13:41:44 +02:00
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
with mock_queue_publish(
"zerver.tornado.event_queue.queue_json_publish"
) as mock_queue_json_publish:
notified = maybe_enqueue_notifications(**params)
mock_queue_json_publish.assert_not_called()
test_event_queue: Introduce helper to fill-up default values. This allows us to only mention the values that are relevant to the behavior being tested by the `check_notify` function in the current assertion.
2021-06-08 15:00:11 +02:00
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
with mock_queue_publish(
"zerver.tornado.event_queue.queue_json_publish"
) as mock_queue_json_publish:
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
params["private_message"] = True
notified = maybe_enqueue_notifications(**params)
self.assertTrue(mock_queue_json_publish.call_count, 2)
notifications: Fix double-sending in missedmessage_hook. While the missedmessage_hook logic originally did a reasonably good job of avoiding double-sending notifications, there was a corner case it didn't handle, namely a user who had been presence-idle when a message was sent and became also event-queue-idle as well within the next 10 minutes. For those users, they got a notification at message send time, and the missedmessage_hook would deliver it a second time. We fix this by just checking the conveniently available push_notified and email_notified variables that indicate whether the message already had a notification triggered. Fixes #7031.
2017-10-18 06:54:03 +02:00
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
queues_pushed = [entry[0][0] for entry in mock_queue_json_publish.call_args_list]
self.assertIn("missedmessage_mobile_notifications", queues_pushed)
self.assertIn("missedmessage_emails", queues_pushed)
tests: Add a test suite for maybe_enqueue_notifications. This ensures that as we expand the logic for under what circumstances email and push notifications should be sent, we can be confident about this code path always doing the right thing.
2017-09-27 20:27:04 +02:00
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
self.assertTrue(notified["email_notified"])
self.assertTrue(notified["push_notified"])
settings: Decouple enable_push_notifications_offline from PM setting. Note that this setting has always applied to both streams and PMs; the test just clarifies that that is the case.
2019-04-18 03:58:25 +02:00
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
def tornado_call(
self,
view_func: Callable[[HttpRequest, UserProfile], HttpResponse],
user_profile: UserProfile,
post_data: Dict[str, Any],
) -> HttpResponse:
refactor: Integrate POSTRequestMock into HostRequestMock. Minimized code duplication by integrating POSTRequestMock into HostRequestMock and then updating the required files with HostRequestMock. Fixes part of #1211.
2021-02-07 21:34:01 +01:00
request = HostRequestMock(post_data, user_profile)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
return view_func(request, user_profile)
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
def test_stream_watchers(self) -> None:
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"""
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
We used to have a bug with stream_watchers, where we set their flags to
None.
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"""
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
cordelia = self.example_user("cordelia")
hamlet = self.example_user("hamlet")
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
realm = hamlet.realm
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
stream_name = "Denmark"
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
self.unsubscribe(hamlet, stream_name)
queue_data = dict(
all_public_streams=True,
apply_markdown=True,
client_gravatar=True,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
client_type_name="home grown API program",
event_types=["message"],
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
last_connection_time=time.time(),
queue_timeout=0,
realm_id=realm.id,
user_profile_id=hamlet.id,
)
client = allocate_client_descriptor(queue_data)
tests: Use users in send_*_message. This commit mostly makes our tests less noisy, since emails are no longer an important detail of sending messages (they're not even really used in the API). It also sets us up to have more scrutiny on delivery_email/email in the future for things that actually matter. (This is a prep commit for something along those lines, kind of hard to explain the full plan.)
2020-03-07 11:43:05 +01:00
self.send_stream_message(cordelia, stream_name)
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
tests: Consistently use assert_length helper. This helper does some nice things like printing out the data structure incase of failure.
2021-05-17 05:41:32 +02:00
self.assert_length(client.event_queue.contents(), 1)
minor: Clean up how we set flags in events. This is basically a simple fix, where we consistently set `flags` to an empty array when we pass it around. The history here is that we had kind of a nasty bug from setting it to `None`, which only showed up in the somewhat obscure circumstance of somebody subscribing to all stream events in our API. Fixes #7921
2018-03-28 21:42:06 +02:00
# This next line of code should silently succeed and basically do
# nothing under the covers. This test is here to prevent a bug
# from re-appearing.
missedmessage_hook(
user_profile_id=hamlet.id,
client=client,
last_for_client=True,
)
zerver/tests: Use python 3 syntax for typing in most files.
2017-11-05 10:51:25 +01:00
def test_end_to_end_missedmessage_hook(self) -> None:
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
"""Tests what arguments missedmessage_hook passes into maybe_enqueue_notifications.
Combined with the previous test, this ensures that the missedmessage_hook is correct"""
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
user_profile = self.example_user("hamlet")
notifications: Enable online push notifications by default. For new user onboarding, it's important for it to be easy to verify that Zulip's mobile push notifications work without jumping through hoops or potentially making mistakes. For that reason, it makes sense to toggle the notification defaults for new users to the more aggressive mode (ignoring whether the user is currently actively online); they can set the more subtle mode if they find that the notifications are annoying.
2019-12-11 01:41:20 +01:00
user_profile.enable_online_push_notifications = False
user_profile.save()
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
iago = self.example_user("iago")
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# Fetch the Denmark stream for testing
stream = get_stream("Denmark", user_profile.realm)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
sub = Subscription.objects.get(
user_profile=user_profile,
recipient__type=Recipient.STREAM,
recipient__type_id=stream.id,
)
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
tests: Limit email-based logins. We now have this API... If you really just need to log in and not do anything with the actual user: self.login('hamlet') If you're gonna use the user in the rest of the test: hamlet = self.example_user('hamlet') self.login_user(hamlet) If you are specifically testing email/password logins (used only in 4 places): self.login_by_email(email, password) And for failures uses this (used twice): self.assert_login_failure(email)
2020-03-06 18:40:46 +01:00
self.login_user(user_profile)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
def change_subscription_properties(
user_profile: UserProfile,
stream: Stream,
sub: Subscription,
properties: Dict[str, bool],
) -> None:
test_event_queue: Make subscription management code readable. This test refactor makes the subscription/stream settings changes use standard APIs and thus be easier to follow (and more robust to subtle re-fetching bugs). This is a follow-up to #9181.
2018-08-08 21:39:19 +02:00
for property_name, value in properties.items():
refactor: Make acting_user a mandatory kwarg for do_change_subscription_property.
2021-04-08 02:41:57 +02:00
do_change_subscription_property(
user_profile, sub, stream, property_name, value, acting_user=None
)
test_event_queue: Make subscription management code readable. This test refactor makes the subscription/stream settings changes use standard APIs and thus be easier to follow (and more robust to subtle re-fetching bugs). This is a follow-up to #9181.
2018-08-08 21:39:19 +02:00
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
def allocate_event_queue() -> ClientDescriptor:
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
result = self.tornado_call(
get_events,
user_profile,
{
"apply_markdown": orjson.dumps(True).decode(),
"client_gravatar": orjson.dumps(True).decode(),
"event_types": orjson.dumps(["message"]).decode(),
"user_client": "website",
"dont_block": orjson.dumps(True).decode(),
},
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
self.assert_json_success(result)
python: Replace ujson with orjson. Fixes #6507. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2020-08-07 01:09:47 +02:00
queue_id = orjson.loads(result.content)["queue_id"]
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
return get_client_descriptor(queue_id)
def destroy_event_queue(queue_id: str) -> None:
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
result = self.tornado_call(cleanup_event_queue, user_profile, {"queue_id": queue_id})
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
self.assert_json_success(result)
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
def assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict: Collection[Any],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id: int,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
**kwargs: Any,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
) -> None:
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
expected_args_dict = self.get_maybe_enqueue_notifications_parameters(
user_id=user_profile.id,
sender_id=iago.id,
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
message_id=message_id,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
**kwargs,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
)
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
self.assertEqual(args_dict, expected_args_dict)
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
client_descriptor = allocate_event_queue()
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
# To test the missed_message hook, we first need to send a message
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark")
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
# Verify that nothing happens if you call it as not the
# "last client descriptor", in which case the function
# short-circuits, since the `missedmessage_hook` handler
# for garbage-collection is only for the user's last queue.
missedmessage_hook(user_profile.id, client_descriptor, False)
mock_enqueue.assert_not_called()
# Now verify that we called the appropriate enqueue function
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_name="Denmark",
already_notified={"email_notified": False, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# Test the hook with a private message; this should trigger notifications
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
client_descriptor = allocate_event_queue()
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_personal_message(iago, user_profile)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
private_message=True,
already_notified={"email_notified": True, "push_notified": True},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# Test the hook with a mention; this should trigger notifications
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
client_descriptor = allocate_event_queue()
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
self.assertTrue(client_descriptor.event_queue.empty())
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
msg_id = self.send_stream_message(
self.example_user("iago"), "Denmark", content="@**King Hamlet** what's up?"
)
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
tests: Add an end-to-end test for missedmessage_hook. This checks what arguments it passes into the enqueuing function. Note, however, that the arguments are wrong for various cases, we'll update the tests as we fix those bugs.
2017-09-27 20:55:58 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
flags=["mentioned"],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
mentioned=True,
stream_name="Denmark",
already_notified={"email_notified": True, "push_notified": True},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
messages: Add email/push notifications for wildcard mentions. 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.
2019-08-26 04:40:07 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# Test the hook with a wildcard mention; this should trigger notifications
messages: Add email/push notifications for wildcard mentions. 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.
2019-08-26 04:40:07 +02:00
client_descriptor = allocate_event_queue()
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="@**all** what's up?")
messages: Add email/push notifications for wildcard mentions. 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.
2019-08-26 04:40:07 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
messages: Add email/push notifications for wildcard mentions. 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.
2019-08-26 04:40:07 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
flags=["wildcard_mentioned"],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
wildcard_mention_notify=True,
stream_name="Denmark",
already_notified={"email_notified": True, "push_notified": True},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# Wildcard mentions in muted streams don't notify.
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
change_subscription_properties(user_profile, stream, sub, {"is_muted": True})
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
client_descriptor = allocate_event_queue()
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="@**all** what's up?")
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
flags=["wildcard_mentioned"],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_name="Denmark",
already_notified={"email_notified": False, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
change_subscription_properties(user_profile, stream, sub, {"is_muted": False})
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
# With wildcard_mentions_notify=False, we treat the user as not mentioned.
user_profile.wildcard_mentions_notify = False
user_profile.save()
client_descriptor = allocate_event_queue()
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="@**all** what's up?")
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
flags=["wildcard_mentioned"],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
stream_name="Denmark",
already_notified={"email_notified": False, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
settings: Add notification settings checkboxes for wildcard mentions. This change makes it possible for users to control the notification settings for wildcard mentions as a separate control from PMs and direct @-mentions.
2019-09-03 23:27:45 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
user_profile.wildcard_mentions_notify = True
user_profile.save()
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
wildcard_mentions_notify: Add per-stream override of global setting. Adds required API and front-end changes to modify and read the wildcard_mentions_notify field in the Subscription model. It includes front-end code to add the setting to the user's "manage streams" page. This setting will be greyed out when a stream is muted. The PR also includes back-end code to add the setting the initial state of a subscription. New automated tests were added for the API, events system and front-end. In manual testing, we checked that modifying the setting in the front end persisted the change in the Subscription model. We noticed the notifications were not behaving exactly as expected in manual testing; see https://github.com/zulip/zulip/issues/13073#issuecomment-560263081 . Tweaked by tabbott to fix real-time synchronization issues. Fixes: #13429.
2019-11-26 02:37:12 +01:00
# If wildcard_mentions_notify=True for a stream and False for a user, we treat the user
# as mentioned for that stream.
user_profile.wildcard_mentions_notify = False
sub.wildcard_mentions_notify = True
user_profile.save()
sub.save()
client_descriptor = allocate_event_queue()
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="@**all** what's up?")
wildcard_mentions_notify: Add per-stream override of global setting. Adds required API and front-end changes to modify and read the wildcard_mentions_notify field in the Subscription model. It includes front-end code to add the setting to the user's "manage streams" page. This setting will be greyed out when a stream is muted. The PR also includes back-end code to add the setting the initial state of a subscription. New automated tests were added for the API, events system and front-end. In manual testing, we checked that modifying the setting in the front end persisted the change in the Subscription model. We noticed the notifications were not behaving exactly as expected in manual testing; see https://github.com/zulip/zulip/issues/13073#issuecomment-560263081 . Tweaked by tabbott to fix real-time synchronization issues. Fixes: #13429.
2019-11-26 02:37:12 +01:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
wildcard_mentions_notify: Add per-stream override of global setting. Adds required API and front-end changes to modify and read the wildcard_mentions_notify field in the Subscription model. It includes front-end code to add the setting to the user's "manage streams" page. This setting will be greyed out when a stream is muted. The PR also includes back-end code to add the setting the initial state of a subscription. New automated tests were added for the API, events system and front-end. In manual testing, we checked that modifying the setting in the front end persisted the change in the Subscription model. We noticed the notifications were not behaving exactly as expected in manual testing; see https://github.com/zulip/zulip/issues/13073#issuecomment-560263081 . Tweaked by tabbott to fix real-time synchronization issues. Fixes: #13429.
2019-11-26 02:37:12 +01:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
flags=["wildcard_mentioned"],
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
wildcard_mention_notify=True,
stream_name="Denmark",
already_notified={"email_notified": True, "push_notified": True},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
wildcard_mentions_notify: Add per-stream override of global setting. Adds required API and front-end changes to modify and read the wildcard_mentions_notify field in the Subscription model. It includes front-end code to add the setting to the user's "manage streams" page. This setting will be greyed out when a stream is muted. The PR also includes back-end code to add the setting the initial state of a subscription. New automated tests were added for the API, events system and front-end. In manual testing, we checked that modifying the setting in the front end persisted the change in the Subscription model. We noticed the notifications were not behaving exactly as expected in manual testing; see https://github.com/zulip/zulip/issues/13073#issuecomment-560263081 . Tweaked by tabbott to fix real-time synchronization issues. Fixes: #13429.
2019-11-26 02:37:12 +01:00
destroy_event_queue(client_descriptor.event_queue.id)
user_profile.wildcard_mentions_notify = True
sub.wildcard_mentions_notify = None
user_profile.save()
sub.save()
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
# Test the hook with a stream message with stream_push_notify
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
change_subscription_properties(user_profile, stream, sub, {"push_notifications": True})
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
client_descriptor = allocate_event_queue()
event_queue: Fixed stream_push_notify code path in missedmessage_hook. This finishes implementing the stream_push_notify feature, which previously didn't work if you were not idle when the message was sent.
2017-09-28 00:04:32 +02:00
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="what's up everyone?")
event_queue: Fixed stream_push_notify code path in missedmessage_hook. This finishes implementing the stream_push_notify feature, which previously didn't work if you were not idle when the message was sent.
2017-09-28 00:04:32 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
event_queue: Fixed stream_push_notify code path in missedmessage_hook. This finishes implementing the stream_push_notify feature, which previously didn't work if you were not idle when the message was sent.
2017-09-28 00:04:32 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_push_notify=True,
stream_email_notify=False,
stream_name="Denmark",
get_active_presence_idle_user_ids: Check notifiability more thoroughly. * Have the `get_active_presence_idle_user_ids` function look at all the user data, not just `private_message` and `mentioned`. * Fix a couple of incorrect `missedmessage_hook` tests, which did not catch the earlier behaviour. * Add some comments to the tests for this function for clarity. * Add a helper to create `UserMessageNotificationsData` objects from the user ID lists. This will later help us deduplicate code in the event_queue logic. This fixes a bug which earlier existed, that if a user turned on stream notifications, and received a message in that stream which did not mention them, they wouldn't be in the `presence_idle_users` list, and hence would never get notifications for that message. Note that, after this commit, users might still not get notifications in the above scenarios in some cases, because the downstream logic in the notification queue consumers sometimes erroneously skips sending notifications for stream messages.
2021-06-18 14:16:16 +02:00
already_notified={"email_notified": False, "push_notified": True},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
event_queue: Add stream_email_notify. This adds support to the event queue system for triggering missed-message notifications (whether push or email) to support the stream push notifications feature.
2017-11-21 07:24:24 +01:00
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
# Test the hook with a stream message with stream_email_notify
client_descriptor = allocate_event_queue()
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
change_subscription_properties(
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
user_profile, stream, sub, {"push_notifications": False, "email_notifications": True}
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
event_queue: Add stream_email_notify. This adds support to the event queue system for triggering missed-message notifications (whether push or email) to support the stream push notifications feature.
2017-11-21 07:24:24 +01:00
self.assertTrue(client_descriptor.event_queue.empty())
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="what's up everyone?")
event_queue: Add stream_email_notify. This adds support to the event queue system for triggering missed-message notifications (whether push or email) to support the stream push notifications feature.
2017-11-21 07:24:24 +01:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
event_queue: Add stream_email_notify. This adds support to the event queue system for triggering missed-message notifications (whether push or email) to support the stream push notifications feature.
2017-11-21 07:24:24 +01:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_push_notify=False,
stream_email_notify=True,
stream_name="Denmark",
get_active_presence_idle_user_ids: Check notifiability more thoroughly. * Have the `get_active_presence_idle_user_ids` function look at all the user data, not just `private_message` and `mentioned`. * Fix a couple of incorrect `missedmessage_hook` tests, which did not catch the earlier behaviour. * Add some comments to the tests for this function for clarity. * Add a helper to create `UserMessageNotificationsData` objects from the user ID lists. This will later help us deduplicate code in the event_queue logic. This fixes a bug which earlier existed, that if a user turned on stream notifications, and received a message in that stream which did not mention them, they wouldn't be in the `presence_idle_users` list, and hence would never get notifications for that message. Note that, after this commit, users might still not get notifications in the above scenarios in some cases, because the downstream logic in the notification queue consumers sometimes erroneously skips sending notifications for stream messages.
2021-06-18 14:16:16 +02:00
already_notified={"email_notified": True, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
event_queue: Fixed stream_push_notify code path in missedmessage_hook. This finishes implementing the stream_push_notify feature, which previously didn't work if you were not idle when the message was sent.
2017-09-28 00:04:32 +02:00
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
# Test the hook with stream message with stream_push_notify on
# a muted topic, which we should not push notify for
client_descriptor = allocate_event_queue()
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
change_subscription_properties(
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
user_profile, stream, sub, {"push_notifications": True, "email_notifications": False}
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
notifications: Add failing test for push notifications on muted topics. This is some pre-work as part of #7059.
2017-10-18 07:49:03 +02:00
self.assertTrue(client_descriptor.event_queue.empty())
refactor: Remove recipient arg for do_mute_topic.
2020-10-16 17:29:05 +02:00
do_mute_topic(user_profile, stream, "mutingtest")
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
msg_id = self.send_stream_message(
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
iago,
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"Denmark",
content="what's up everyone?",
topic_name="mutingtest",
)
notifications: Add failing test for push notifications on muted topics. This is some pre-work as part of #7059.
2017-10-18 07:49:03 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
notifications: Add failing test for push notifications on muted topics. This is some pre-work as part of #7059.
2017-10-18 07:49:03 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_name="Denmark",
already_notified={"email_notified": False, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
notifications: Add failing test for push notifications on muted topics. This is some pre-work as part of #7059.
2017-10-18 07:49:03 +02:00
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
# Test the hook with stream message with stream_email_notify on
# a muted stream, which we should not push notify for
client_descriptor = allocate_event_queue()
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
change_subscription_properties(
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
user_profile, stream, sub, {"push_notifications": False, "email_notifications": True}
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
notifications: Fix sending push notifications on muted streams. Apparently, the stream muting feature did not take priority over the stream_push_notify feature. This fixes that gap. Fixes zulip/zulip-mobile#1314.
2017-10-18 07:38:54 +02:00
self.assertTrue(client_descriptor.event_queue.empty())
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
change_subscription_properties(user_profile, stream, sub, {"is_muted": True})
event_queue: Extract local variables.
2021-06-11 14:27:00 +02:00
msg_id = self.send_stream_message(iago, "Denmark", content="what's up everyone?")
notifications: Fix sending push notifications on muted streams. Apparently, the stream muting feature did not take priority over the stream_push_notify feature. This fixes that gap. Fixes zulip/zulip-mobile#1314.
2017-10-18 07:38:54 +02:00
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict = mock_enqueue.call_args_list[0][1]
notifications: Fix sending push notifications on muted streams. Apparently, the stream muting feature did not take priority over the stream_push_notify feature. This fixes that gap. Fixes zulip/zulip-mobile#1314.
2017-10-18 07:38:54 +02:00
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
assert_maybe_enqueue_notifications_call_args(
maybe_enqueue_notifications: Require all keyword arguments. This is a more readable way to call the function.
2021-06-23 12:25:38 +02:00
args_dict=args_dict,
test_event_queue: Don't use lists for call_args assertions. This is a bit hacky, but will make these tests more readable, in that the reader would not have to remember the order or parameter names. Python 3.8 introduced `mock.call_args.kwargs`, and once we upgrade, we can use those to assert actual dictionaries instead of this hack.
2021-05-31 10:52:32 +02:00
message_id=msg_id,
stream_name="Denmark",
already_notified={"email_notified": False, "push_notified": False},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
test_event_queue: Clean up testing setup. Rather than continually resetting the contents of an existing event queue, we allocate a new one for each subtest. We also fix a rather confusing bundle of comments.
2019-08-26 04:35:47 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
notifications: Fix sending push notifications on muted streams. Apparently, the stream muting feature did not take priority over the stream_push_notify feature. This fixes that gap. Fixes zulip/zulip-mobile#1314.
2017-10-18 07:38:54 +02:00
# Clean up the state we just changed (not necessary unless we add more test code below)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
change_subscription_properties(
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
user_profile, stream, sub, {"push_notifications": True, "is_muted": False}
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
missedmessage_hook: Don't enqueue notificationss if sender is muted. This is a follow up to 71742dce24869d55c232e14b53cbc22ae09a2135 to handle muted senders in the missedmessage_hook too.
2021-06-14 14:30:45 +02:00
# Test the hook when the sender has been muted
result = self.api_post(user_profile, f"/api/v1/users/me/muted_users/{iago.id}")
self.assert_json_success(result)
client_descriptor = allocate_event_queue()
self.assertTrue(client_descriptor.event_queue.empty())
msg_id = self.send_personal_message(iago, user_profile)
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
missedmessage_hook(user_profile.id, client_descriptor, True)
maybe_enqueue_notifications: Take in notification_data dataclass. * Modify `maybe_enqueue_notifications` to take in an instance of the dataclass introduced in 951b49c048ba3464e74ad7965da3453fe36d0a96. * The `check_notify` tests tested the "when to notify" logic in a way which involved `maybe_enqueue_notifications`. To simplify things, we've earlier extracted this logic in 8182632d7e9f8490b9b9295e01b5912dcf173fd5. So, we just kill off the `check_notify` test, and keep only those parts which verify the queueing and return value behavior of that funtion. * We retain the the missedmessage_hook and message message_edit_notifications since they are more integration-style. * There's a slightly subtle change with the missedmessage_hook tests. Before this commit, we short-circuited the hook if the sender was muted (5a642cea115be159175d1189f83ba25d2c5c7632). With this commit, we delegate the check to our dataclass methods. So, `maybe_enqueue_notifications` will be called even if the sender was muted, and the test needs to be updated. * In our test helper `get_maybe_enqueue_notifications_parameters` which generates default values for testing `maybe_enqueue_notifications` calls, we keep `message_id`, `sender_id`, and `user_id` as required arguments, so that the tests are super-clear and avoid accidental false positives. * Because `do_update_embedded_data` also sends `update_message` events, we deal with that case with some hacky code for now. See the comment there. This mostly completes the extraction of the "when to notify" logic into our new `notification_data` module.
2021-06-23 14:12:32 +02:00
mock_enqueue.assert_called_once()
args_dict = mock_enqueue.call_args_list[0][1]
assert_maybe_enqueue_notifications_call_args(
args_dict=args_dict,
message_id=msg_id,
private_message=True,
sender_is_muted=True,
flags=["read"],
already_notified={"email_notified": False, "push_notified": False},
)
missedmessage_hook: Don't enqueue notificationss if sender is muted. This is a follow up to 71742dce24869d55c232e14b53cbc22ae09a2135 to handle muted senders in the missedmessage_hook too.
2021-06-14 14:30:45 +02:00
destroy_event_queue(client_descriptor.event_queue.id)
result = self.api_delete(user_profile, f"/api/v1/users/me/muted_users/{iago.id}")
self.assert_json_success(result)
tornado: Support using a port-aware file for dumping event queues. This should make it possible for there to safely be multiple Tornado processes running on different ports on the same system. It may also fix a rare race bug in development, where previously, it was possible for the Tornados processes for Casper and the main development server to interfere; I haven't investigated whether this was a real bug or not, but now those two services will use independent Tornado files. We still need to add something to direct traffic between the different Tornado processes.
2018-10-04 00:22:39 +02:00
class FileReloadLogicTest(ZulipTestCase):
def test_persistent_queue_filename(self) -> None:
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
with self.settings(
JSON_PERSISTENT_QUEUE_FILENAME_PATTERN="/home/zulip/tornado/event_queues%s.json"
):
self.assertEqual(
persistent_queue_filename(9800), "/home/zulip/tornado/event_queues.json"
)
self.assertEqual(
persistent_queue_filename(9800, last=True),
"/home/zulip/tornado/event_queues.json.last",
)
with self.settings(
JSON_PERSISTENT_QUEUE_FILENAME_PATTERN="/home/zulip/tornado/event_queues%s.json",
TORNADO_PROCESSES=4,
):
self.assertEqual(
persistent_queue_filename(9800), "/home/zulip/tornado/event_queues.9800.json"
)
self.assertEqual(
persistent_queue_filename(9800, last=True),
"/home/zulip/tornado/event_queues.9800.last.json",
)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
event_queue: Remove internal fields being leaked to the API. A few internal fields used for tracking which types of notifications have already been sent for a given message, like `hander_id` and the `push_notified` bundle of fields were being incorrectly included in message events delivered to clients clients. One could argue these fields might be useful hints to clients, but because notifications can be triggered later on via `missedmessage_hook`, they have no useful purpose in the API. This commit move these extended event field on a `internal_data` object within the event object, and delete this field in `contents()` for call points that would serve data to clients. Tweaked by tabbott to provide a cleaner interface. We're not bumping API_FEATURE_LEVEL because these fields have always been documented as being present only due to a bug, so no clients should be expecting or relying on them. Fixes: #15947.
2020-12-22 10:43:34 +01:00
class PruneInternalDataTest(ZulipTestCase):
def test_prune_internal_data(self) -> None:
user_profile = self.example_user("hamlet")
queue_data = dict(
all_public_streams=True,
apply_markdown=True,
client_gravatar=True,
client_type_name="website",
event_types=["message"],
last_connection_time=time.time(),
queue_timeout=600,
realm_id=user_profile.realm.id,
user_profile_id=user_profile.id,
)
client = allocate_client_descriptor(queue_data)
self.assertTrue(client.event_queue.empty())
self.send_stream_message(
self.example_user("iago"), "Denmark", content="@**King Hamlet** what's up?"
)
self.send_stream_message(
self.example_user("iago"), "Denmark", content="@**all** what's up?"
)
self.send_personal_message(self.example_user("iago"), user_profile)
events = client.event_queue.contents()
tests: Consistently use assert_length helper. This helper does some nice things like printing out the data structure incase of failure.
2021-05-17 05:41:32 +02:00
self.assert_length(events, 3)
event_queue: Remove internal fields being leaked to the API. A few internal fields used for tracking which types of notifications have already been sent for a given message, like `hander_id` and the `push_notified` bundle of fields were being incorrectly included in message events delivered to clients clients. One could argue these fields might be useful hints to clients, but because notifications can be triggered later on via `missedmessage_hook`, they have no useful purpose in the API. This commit move these extended event field on a `internal_data` object within the event object, and delete this field in `contents()` for call points that would serve data to clients. Tweaked by tabbott to provide a cleaner interface. We're not bumping API_FEATURE_LEVEL because these fields have always been documented as being present only due to a bug, so no clients should be expecting or relying on them. Fixes: #15947.
2020-12-22 10:43:34 +01:00
self.assertFalse("internal_data" in events[0])
self.assertFalse("internal_data" in events[1])
self.assertFalse("internal_data" in events[2])
events = client.event_queue.contents(include_internal_data=True)
self.assertTrue("internal_data" in events[0])
self.assertTrue("internal_data" in events[1])
self.assertTrue("internal_data" in events[2])
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
class EventQueueTest(ZulipTestCase):
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
def get_client_descriptor(self) -> ClientDescriptor:
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
hamlet = self.example_user("hamlet")
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
realm = hamlet.realm
queue_data = dict(
all_public_streams=False,
apply_markdown=False,
client_gravatar=True,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
client_type_name="website",
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
event_types=None,
last_connection_time=time.time(),
queue_timeout=0,
realm_id=realm.id,
user_profile_id=hamlet.id,
)
client = allocate_client_descriptor(queue_data)
return client
def verify_to_dict_end_to_end(self, client: ClientDescriptor) -> None:
client_dict = client.to_dict()
new_client = ClientDescriptor.from_dict(client_dict)
self.assertEqual(client.to_dict(), new_client.to_dict())
events: Check last_event_id for validity, take 2. This verifies that the client passed a last_event_id that actually came from the queue instead of making up an ID from the future. It turns out one of our tests was making up such an ID, but legitimate clients are expected not to do so. The previous version of this commit (commit e00d4be6d57ca8282a668f9aec2c835d367c6f69, #12888) had to be reverted (commit b86c5cc4903e737bb95aafa240ca3706d090c453) because it was missing the `to_dict`/`from_dict` migration code. Signed-off-by: Anders Kaseorg <anders@zulipchat.com>
2019-08-06 00:08:56 +02:00
client_dict = client.to_dict()
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
del client_dict["event_queue"]["newest_pruned_id"]
events: Check last_event_id for validity, take 2. This verifies that the client passed a last_event_id that actually came from the queue instead of making up an ID from the future. It turns out one of our tests was making up such an ID, but legitimate clients are expected not to do so. The previous version of this commit (commit e00d4be6d57ca8282a668f9aec2c835d367c6f69, #12888) had to be reverted (commit b86c5cc4903e737bb95aafa240ca3706d090c453) because it was missing the `to_dict`/`from_dict` migration code. Signed-off-by: Anders Kaseorg <anders@zulipchat.com>
2019-08-06 00:08:56 +02:00
new_client = ClientDescriptor.from_dict(client_dict)
self.assertEqual(client_dict, new_client.to_dict())
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
def test_one_event(self) -> None:
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
client = self.get_client_descriptor()
queue = client.event_queue
pointer tests: Fix test_one_event.
2020-06-26 13:40:19 +02:00
in_dict = dict(
type="arbitrary",
x="foo",
y=42,
z=False,
timestamp="1",
)
out_dict = dict(
id=0,
**in_dict,
)
queue.push(in_dict)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
self.assertFalse(queue.empty())
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
pointer tests: Fix test_one_event.
2020-06-26 13:40:19 +02:00
self.assertEqual(queue.contents(), [out_dict])
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
def test_event_collapsing(self) -> None:
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
client = self.get_client_descriptor()
queue = client.event_queue
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"""
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
The update_message_flags events are special, because
they can be collapsed together. Given two umfe's, we:
* use the latest timestamp
* concatenate the messages
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"""
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
def umfe(timestamp: int, messages: List[int]) -> Dict[str, Any]:
return dict(
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
type="update_message_flags",
operation="add",
flag="read",
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
all=False,
timestamp=timestamp,
messages=messages,
)
events = [
umfe(timestamp=1, messages=[101]),
umfe(timestamp=2, messages=[201, 202]),
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
dict(type="unknown"),
dict(type="restart", server_generation="1"),
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
umfe(timestamp=3, messages=[301, 302, 303]),
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
dict(type="restart", server_generation="2"),
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
umfe(timestamp=4, messages=[401, 402, 403, 404]),
]
for event in events:
queue.push(event)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
self.assertEqual(
queue.contents(),
[
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
dict(id=2, type="unknown"),
dict(id=5, type="restart", server_generation="2"),
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
dict(
id=6,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
type="update_message_flags",
operation="add",
flag="read",
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
all=False,
timestamp=4,
messages=[101, 201, 202, 301, 302, 303, 401, 402, 403, 404],
),
],
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"""
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
Note that calling queue.contents() has the side
effect that we will no longer be able to collapse
the previous events, so the next event will just
get added to the queue, rather than collapsed.
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"""
tests: Simplify test_event_collapsing. We now use update_message_flags instead of pointer events.
2020-06-26 14:14:36 +02:00
queue.push(
umfe(timestamp=5, messages=[501, 502, 503, 504, 505]),
)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
self.assertEqual(
queue.contents(),
[
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
dict(id=2, type="unknown"),
dict(id=5, type="restart", server_generation="2"),
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
dict(
id=6,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
type="update_message_flags",
operation="add",
flag="read",
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
all=False,
timestamp=4,
messages=[101, 201, 202, 301, 302, 303, 401, 402, 403, 404],
),
dict(
id=7,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
type="update_message_flags",
operation="add",
flag="read",
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
all=False,
timestamp=5,
messages=[501, 502, 503, 504, 505],
),
],
)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
def test_flag_add_collapsing(self) -> None:
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
client = self.get_client_descriptor()
queue = client.event_queue
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push(
{
"type": "update_message_flags",
"flag": "read",
"operation": "add",
"all": False,
"messages": [1, 2, 3, 4],
"timestamp": "1",
}
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push(
{
"type": "update_message_flags",
"flag": "read",
"all": False,
"operation": "add",
"messages": [5, 6],
"timestamp": "1",
}
)
self.verify_to_dict_end_to_end(client)
self.assertEqual(
queue.contents(),
[
{
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"id": 1,
"type": "update_message_flags",
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
"all": False,
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"flag": "read",
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
"operation": "add",
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"messages": [1, 2, 3, 4, 5, 6],
"timestamp": "1",
}
],
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
def test_flag_remove_collapsing(self) -> None:
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
client = self.get_client_descriptor()
queue = client.event_queue
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push(
{
"type": "update_message_flags",
"flag": "collapsed",
"operation": "remove",
"all": False,
"messages": [1, 2, 3, 4],
"timestamp": "1",
}
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push(
{
"type": "update_message_flags",
"flag": "collapsed",
"all": False,
"operation": "remove",
"messages": [5, 6],
"timestamp": "1",
}
)
self.verify_to_dict_end_to_end(client)
self.assertEqual(
queue.contents(),
[
{
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
"id": 1,
"type": "update_message_flags",
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
"all": False,
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"flag": "collapsed",
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
"operation": "remove",
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"messages": [1, 2, 3, 4, 5, 6],
"timestamp": "1",
}
],
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
self.verify_to_dict_end_to_end(client)
tests: Move EventQueueTest to test_event_queue.py. This seems more appropriate, especially as we expand this library.
2019-08-02 21:50:27 +02:00
def test_collapse_event(self) -> None:
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"""
pointer tests: Use restart for test_collapse_event. The restart event was always handled pretty similarly to pointer, so I use restart events now for this test (in preparation of eliminating pointer events).
2020-06-26 16:11:38 +02:00
This mostly focues on the internals of
how we store "virtual_events" that we
can collapse if subsequent events are
of the same form. See the code in
EventQueue.push for more context.
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
"""
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
client = self.get_client_descriptor()
queue = client.event_queue
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push({"type": "restart", "server_generation": 1, "timestamp": "1"})
pointer tests: Use restart for test_collapse_event. The restart event was always handled pretty similarly to pointer, so I use restart events now for this test (in preparation of eliminating pointer events).
2020-06-26 16:11:38 +02:00
# Verify the server_generation event is stored as a virtual event
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
self.assertEqual(
queue.virtual_events,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
{"restart": {"id": 0, "type": "restart", "server_generation": 1, "timestamp": "1"}},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
# And we can reconstruct newest_pruned_id etc.
self.verify_to_dict_end_to_end(client)
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
queue.push({"type": "unknown", "timestamp": "1"})
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
self.assertEqual(list(queue.queue), [{"id": 1, "type": "unknown", "timestamp": "1"}])
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
self.assertEqual(
queue.virtual_events,
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
{"restart": {"id": 0, "type": "restart", "server_generation": 1, "timestamp": "1"}},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
# And we can still reconstruct newest_pruned_id etc. correctly
self.verify_to_dict_end_to_end(client)
# Verify virtual events are converted to real events by .contents()
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
self.assertEqual(
queue.contents(),
[
python: Normalize quotes with Black. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:20:45 +01:00
{"id": 0, "type": "restart", "server_generation": 1, "timestamp": "1"},
{"id": 1, "type": "unknown", "timestamp": "1"},
python: Reformat with Black, except quotes. Signed-off-by: Anders Kaseorg <anders@zulip.com>
2021-02-12 08:19:30 +01:00
],
)
event_queue: Expand testing of event queue save/restore. This verifies that every valid state of our event queue system will be properly save/restored via the from_dict methods.
2019-08-02 22:23:05 +02:00
# And now verify to_dict after pruning
queue.prune(0)
self.verify_to_dict_end_to_end(client)
queue.prune(1)
self.verify_to_dict_end_to_end(client)
event_queue: Translation code for user data migration. This is separate from the next commit for ease of testing. To verify that the compatibility code works correctly, all message send and event_queue tests from our test suite should pass on just this commit.
2021-06-18 19:30:57 +02:00
class SchemaMigrationsTests(ZulipTestCase):
def test_reformat_legacy_send_message_event(self) -> None:
hamlet = self.example_user("hamlet")
cordelia = self.example_user("cordelia")
othello = self.example_user("othello")
old_format_event = dict(
type="message",
message=1,
message_dict={},
presence_idle_user_ids=[hamlet.id, othello.id],
)
old_format_users = [
dict(
id=hamlet.id,
flags=["mentioned"],
mentioned=True,
online_push_enabled=True,
stream_push_notify=False,
stream_email_notify=True,
wildcard_mention_notify=False,
sender_is_muted=False,
),
dict(
id=cordelia.id,
flags=["wildcard_mentioned"],
mentioned=False,
online_push_enabled=True,
stream_push_notify=True,
stream_email_notify=False,
wildcard_mention_notify=True,
sender_is_muted=False,
),
]
notice = dict(event=old_format_event, users=old_format_users)
expected_current_format_users = [
dict(
id=hamlet.id,
flags=["mentioned"],
),
dict(
id=cordelia.id,
flags=["wildcard_mentioned"],
),
]
expected_current_format_event = dict(
type="message",
message=1,
message_dict={},
presence_idle_user_ids=[hamlet.id, othello.id],
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],
muted_sender_user_ids=[],
)
with mock.patch("zerver.tornado.event_queue.process_message_event") as m:
process_notification(notice)
m.assert_called_once()
self.assertDictEqual(m.call_args[0][0], expected_current_format_event)
self.assertEqual(m.call_args[0][1], expected_current_format_users)