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

554 lines
27 KiB
Python
Raw Normal View History

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
import mock
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
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
import ujson
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
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
from typing import Any, Callable, Dict, Tuple
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.lib.actions import do_mute_topic, do_change_subscription_property
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
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 zerver.lib.test_helpers import POSTRequestMock
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
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 zerver.tornado.event_queue import maybe_enqueue_notifications, \
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
allocate_client_descriptor, ClientDescriptor, \
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
get_client_descriptor, missedmessage_hook, persistent_queue_filename
tornado: Split get_events_backend into two functions. The lower-layer function, now called get_events_backend, is intended to be called by multiple code paths (including the upcoming get_events_internal).
2018-07-13 13:10:12 +02:00
from zerver.tornado.views import 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"""
zerver/tests: Use python 3 syntax for typing in most files.
2017-11-05 10:51:25 +01:00
def check_will_notify(self, *args: Any, **kwargs: Any) -> Tuple[str, str]:
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
email_notice = None
mobile_notice = None
with mock.patch("zerver.tornado.event_queue.queue_json_publish") as mock_queue_publish:
notified = maybe_enqueue_notifications(*args, **kwargs)
for entry in mock_queue_publish.call_args_list:
args = entry[0]
if args[0] == "missedmessage_mobile_notifications":
mobile_notice = args[1]
if args[0] == "missedmessage_emails":
email_notice = args[1]
# Now verify the return value matches the queue actions
if email_notice:
self.assertTrue(notified['email_notified'])
else:
self.assertFalse(notified.get('email_notified', False))
if mobile_notice:
self.assertTrue(notified['push_notified'])
else:
self.assertFalse(notified.get('push_notified', False))
return email_notice, mobile_notice
zerver/tests: Use python 3 syntax for typing in most files.
2017-11-05 10:51:25 +01:00
def test_enqueue_notifications(self) -> None:
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
user_profile = self.example_user("hamlet")
message_id = 32
# Boring message doesn't send a notice
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=False,
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
mentioned=False, stream_push_notify=False, stream_email_notify=False,
stream_name=None, always_push_notify=False, idle=True, already_notified={})
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
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is None)
# Private message sends a notice
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=True,
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
mentioned=False, stream_push_notify=False, stream_email_notify=True,
stream_name=None, always_push_notify=False, idle=True, already_notified={})
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
self.assertTrue(email_notice is not None)
self.assertTrue(mobile_notice is not None)
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
# Private message won't double-send either notice if we've
# already sent notices before.
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=True,
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
mentioned=False, stream_push_notify=False, stream_email_notify=False,
stream_name=None, always_push_notify=False, idle=True, already_notified={
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
'push_notified': True,
'email_notified': False,
})
self.assertTrue(email_notice is not None)
self.assertTrue(mobile_notice is None)
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=True,
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
mentioned=False, stream_push_notify=False, stream_email_notify=False,
stream_name=None, always_push_notify=False, idle=True, already_notified={
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
'push_notified': False,
'email_notified': True,
})
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is not None)
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
# Mention sends a notice
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=False,
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
mentioned=True, stream_push_notify=False, stream_email_notify=False,
stream_name=None, always_push_notify=False, idle=True, already_notified={})
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
self.assertTrue(email_notice is not None)
self.assertTrue(mobile_notice is not None)
# stream_push_notify pushes but doesn't email
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=False,
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
mentioned=False, stream_push_notify=True, stream_email_notify=False,
stream_name="Denmark", always_push_notify=False, idle=True, already_notified={})
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
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is not None)
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
# stream_email_notify emails but doesn't push
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=False,
mentioned=False, stream_push_notify=False, stream_email_notify=True,
stream_name="Denmark", always_push_notify=False, idle=True, already_notified={})
self.assertTrue(email_notice is not None)
self.assertTrue(mobile_notice is None)
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
# Private message doesn't send a notice if not idle
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=True,
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
mentioned=False, stream_push_notify=False, stream_email_notify=True,
stream_name=None, always_push_notify=False, idle=False, already_notified={})
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
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is None)
# Private message sends push but not email if not idle but always_push_notify
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=True,
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
mentioned=False, stream_push_notify=False, stream_email_notify=True,
stream_name=None, always_push_notify=True, idle=False, already_notified={})
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
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is not 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
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
# Stream message sends push but not email if not idle but always_push_notify
email_notice, mobile_notice = self.check_will_notify(
user_profile.id, message_id, private_message=False,
mentioned=False, stream_push_notify=True, stream_email_notify=True,
stream_name="Denmark", always_push_notify=True, idle=False, already_notified={})
self.assertTrue(email_notice is None)
self.assertTrue(mobile_notice is not None)
zerver/tests: Use python 3 syntax for typing in most files.
2017-11-05 10:51:25 +01:00
def tornado_call(self, view_func: Callable[[HttpRequest, UserProfile], HttpResponse],
user_profile: UserProfile, post_data: Dict[str, Any]) -> HttpResponse:
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
request = POSTRequestMock(post_data, user_profile)
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:
'''
We used to have a bug with stream_watchers, where we set their flags to
None.
'''
cordelia = self.example_user('cordelia')
hamlet = self.example_user('hamlet')
realm = hamlet.realm
stream_name = 'Denmark'
self.unsubscribe(hamlet, stream_name)
queue_data = dict(
all_public_streams=True,
apply_markdown=True,
client_gravatar=True,
client_type_name='home grown api program',
event_types=['message'],
last_connection_time=time.time(),
queue_timeout=0,
realm_id=realm.id,
user_profile_id=hamlet.id,
)
client = allocate_client_descriptor(queue_data)
self.send_stream_message(cordelia.email, stream_name)
self.assertEqual(len(client.event_queue.contents()), 1)
# 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"""
user_profile = self.example_user('hamlet')
email = user_profile.email
self.login(email)
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
def change_subscription_properties(user_profile: UserProfile, stream: Stream, sub: Subscription,
properties: Dict[str, bool]) -> None:
for property_name, value in properties.items():
do_change_subscription_property(user_profile, sub, stream, property_name, value)
tornado: Split get_events_backend into two functions. The lower-layer function, now called get_events_backend, is intended to be called by multiple code paths (including the upcoming get_events_internal).
2018-07-13 13:10:12 +02:00
result = self.tornado_call(get_events, 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
{"apply_markdown": ujson.dumps(True),
Support client_gravatar field for event registration. This commit allows clients to register client_gravatar=True, and then we recognize that flag for message events. If the flag is True, we will not calculate gravatar URLs and let the clients do it themselves. (Clients can calculate gravatar URLs based on emails with just a little bit of code.)
2017-10-31 18:36:18 +01:00
"client_gravatar": ujson.dumps(True),
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
"event_types": ujson.dumps(["message"]),
"user_client": "website",
"dont_block": ujson.dumps(True),
})
self.assert_json_success(result)
queue_id = ujson.loads(result.content)["queue_id"]
client_descriptor = get_client_descriptor(queue_id)
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
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_stream_message(self.example_email("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()
args_list = mock_enqueue.call_args_list[0][0]
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.assertEqual(args_list, (user_profile.id, msg_id, False, False, False, False,
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
"Denmark", False, True,
{'email_notified': False, 'push_notified': False}))
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
# Clear the event queue, before repeating with a private message
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_personal_message(self.example_email("iago"), email)
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()
args_list = mock_enqueue.call_args_list[0][0]
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.assertEqual(args_list, (user_profile.id, msg_id, True, False, False,
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
False, None, False, True,
{'email_notified': True, 'push_notified': True}))
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
# Clear the event queue, now repeat with a mention
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_stream_message(self.example_email("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:
# Clear the event queue, before repeating with a private message
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
args_list = mock_enqueue.call_args_list[0][0]
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.assertEqual(args_list, (user_profile.id, msg_id, False, True, False,
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
False, "Denmark", False, True,
{'email_notified': True, 'push_notified': True}))
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
stream = get_stream("Denmark", user_profile.realm)
sub = Subscription.objects.get(user_profile=user_profile, recipient__type=Recipient.STREAM,
recipient__type_id=stream.id)
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
# Clear the event queue, now repeat with stream message with stream_push_notify
change_subscription_properties(user_profile, stream, sub, {'push_notifications': True})
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
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_stream_message(self.example_email("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:
# Clear the event queue, before repeating with a private message
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
args_list = mock_enqueue.call_args_list[0][0]
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
self.assertEqual(args_list, (user_profile.id, msg_id, False, False,
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
True, False, "Denmark", False, True,
{'email_notified': False, 'push_notified': False}))
# Clear the event queue, now repeat with stream message with stream_email_notify
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
change_subscription_properties(user_profile, stream, sub,
{'push_notifications': False,
'email_notifications': True})
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
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
msg_id = self.send_stream_message(self.example_email("iago"), "Denmark",
content="what's up everyone?")
with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
# Clear the event queue, before repeating with a private message
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
args_list = mock_enqueue.call_args_list[0][0]
self.assertEqual(args_list, (user_profile.id, msg_id, False, False,
False, True, "Denmark", False, True,
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
{'email_notified': False, 'push_notified': False}))
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
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
# Clear the event queue, now repeat with stream message with stream_push_notify
# on a muted topic, which we should not push notify for
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
change_subscription_properties(user_profile, stream, sub,
{'push_notifications': True,
'email_notifications': False})
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
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
do_mute_topic(user_profile, stream, sub.recipient, "mutingtest")
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_stream_message(self.example_email("iago"), "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:
# Clear the event queue, before repeating with a private message
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
args_list = mock_enqueue.call_args_list[0][0]
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.assertEqual(args_list, (user_profile.id, msg_id, False, False, False,
Excluded topic-muted users from stream push notifications. Fixes #7059
2017-10-24 00:07:03 +02:00
False, "Denmark", False, True,
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
{'email_notified': False, 'push_notified': False}))
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
# Clear the event queue, now repeat with stream message with stream_email_notify
# on a muted stream, which we should not email notify for
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
change_subscription_properties(user_profile, stream, sub,
{'push_notifications': False,
'email_notifications': True})
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
client_descriptor.event_queue.pop()
self.assertTrue(client_descriptor.event_queue.empty())
models: Rename Subscription.in_home_view field to is_muted. This renames Subscription.in_home_view field to is_muted, for greater clarity as to what it does just from seeing the setting name, without having to look it up. Also disabled an obsolete test_migrations test. Fixes #10042.
2018-08-02 23:46:05 +02:00
change_subscription_properties(user_profile, stream, sub, {'is_muted': True})
tests: Fix send_message calls in test_event_queue.py.
2017-10-28 16:22:01 +02:00
msg_id = self.send_stream_message(self.example_email("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:
# Clear the event queue, before repeating with a private message
missedmessage_hook(user_profile.id, client_descriptor, True)
mock_enqueue.assert_called_once()
args_list = mock_enqueue.call_args_list[0][0]
self.assertEqual(args_list, (user_profile.id, msg_id, False, False,
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
False, False, "Denmark", False, True,
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
{'email_notified': False, 'push_notified': False}))
# Clean up the state we just changed (not necessary unless we add more test code below)
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
change_subscription_properties(user_profile, stream, sub,
{'push_notifications': True,
models: Rename Subscription.in_home_view field to is_muted. This renames Subscription.in_home_view field to is_muted, for greater clarity as to what it does just from seeing the setting name, without having to look it up. Also disabled an obsolete test_migrations test. Fixes #10042.
2018-08-02 23:46:05 +02:00
'is_muted': False})
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:
event_queue: Avoid hardcoded paths in /var/tmp. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
2019-01-15 03:03:10 +01:00
with self.settings(JSON_PERSISTENT_QUEUE_FILENAME_PATTERN="/home/zulip/tornado/event_queues%s.json"):
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
self.assertEqual(persistent_queue_filename(9993),
event_queue: Avoid hardcoded paths in /var/tmp. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
2019-01-15 03:03:10 +01:00
"/home/zulip/tornado/event_queues.json")
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
self.assertEqual(persistent_queue_filename(9993, last=True),
event_queue: Avoid hardcoded paths in /var/tmp. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
2019-01-15 03:03:10 +01:00
"/home/zulip/tornado/event_queues.json.last")
with self.settings(JSON_PERSISTENT_QUEUE_FILENAME_PATTERN="/home/zulip/tornado/event_queues%s.json",
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
TORNADO_PROCESSES=4):
self.assertEqual(persistent_queue_filename(9993),
event_queue: Avoid hardcoded paths in /var/tmp. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
2019-01-15 03:03:10 +01:00
"/home/zulip/tornado/event_queues.9993.json")
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
self.assertEqual(persistent_queue_filename(9993, last=True),
event_queue: Avoid hardcoded paths in /var/tmp. Signed-off-by: Anders Kaseorg <andersk@mit.edu>
2019-01-15 03:03:10 +01:00
"/home/zulip/tornado/event_queues.9993.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
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:
hamlet = self.example_user('hamlet')
realm = hamlet.realm
queue_data = dict(
all_public_streams=False,
apply_markdown=False,
client_gravatar=True,
client_type_name='website',
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())
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
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
queue.push({"type": "pointer",
"pointer": 1,
"timestamp": "1"})
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)
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.assertEqual(queue.contents(),
[{'id': 0,
'type': 'pointer',
"pointer": 1,
"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_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
for pointer_val in range(1, 10):
queue.push({"type": "pointer",
"pointer": pointer_val,
"timestamp": str(pointer_val)})
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
self.assertEqual(queue.contents(),
[{'id': 8,
'type': 'pointer',
"pointer": 9,
"timestamp": "9"}])
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
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
for pointer_val in range(1, 10):
queue.push({"type": "pointer",
"pointer": pointer_val,
"timestamp": str(pointer_val)})
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
queue.push({"type": "unknown"})
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
queue.push({"type": "restart", "server_generation": "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
for pointer_val in range(11, 20):
queue.push({"type": "pointer",
"pointer": pointer_val,
"timestamp": str(pointer_val)})
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
queue.push({"type": "restart", "server_generation": "2"})
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
self.assertEqual(queue.contents(),
[{"type": "unknown",
"id": 9},
{'id': 19,
'type': 'pointer',
"pointer": 19,
"timestamp": "19"},
{"id": 20,
"type": "restart",
"server_generation": "2"}])
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
for pointer_val in range(21, 23):
queue.push({"type": "pointer",
"pointer": pointer_val,
"timestamp": str(pointer_val)})
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
self.assertEqual(queue.contents(),
[{"type": "unknown",
"id": 9},
{'id': 19,
'type': 'pointer',
"pointer": 19,
"timestamp": "19"},
{"id": 20,
"type": "restart",
"server_generation": "2"},
{'id': 22,
'type': 'pointer',
"pointer": 22,
"timestamp": "22"},
])
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_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
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
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)
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
queue.push({"type": "update_message_flags",
"flag": "read",
"all": False,
"operation": "add",
"messages": [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
self.assertEqual(queue.contents(),
[{'id': 1,
'type': 'update_message_flags',
"all": False,
"flag": "read",
"operation": "add",
"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
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
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)
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
queue.push({"type": "update_message_flags",
"flag": "collapsed",
"all": False,
"operation": "remove",
"messages": [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
self.assertEqual(queue.contents(),
[{'id': 1,
'type': 'update_message_flags',
"all": False,
"flag": "collapsed",
"operation": "remove",
"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:
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
queue.push({"type": "pointer",
"pointer": 1,
"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
# Verify the pointer event is stored as a virtual event
self.assertEqual(queue.virtual_events,
{'pointer':
{'id': 0,
'type': 'pointer',
'pointer': 1,
"timestamp": "1"}})
# And we can reconstruct newest_pruned_id etc.
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
queue.push({"type": "unknown",
"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.assertEqual(list(queue.queue),
[{'id': 1,
'type': 'unknown',
"timestamp": "1"}])
self.assertEqual(queue.virtual_events,
{'pointer':
{'id': 0,
'type': 'pointer',
'pointer': 1,
"timestamp": "1"}})
# 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()
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.assertEqual(queue.contents(),
[{'id': 0,
'type': 'pointer',
"pointer": 1,
"timestamp": "1"},
{'id': 1,
'type': 'unknown',
"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
# 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)