From c1e027fbe567c47c222c87804365b61c147c726a Mon Sep 17 00:00:00 2001 From: Mohit Gupta Date: Mon, 6 Jul 2020 03:45:22 +0530 Subject: [PATCH] tests: Move StreamMessagesTest to test_message_send.py. StreamMessagesTest test stuff after message is sent to a stream, so moving it out from test_messages.py to test_message_send.py. --- zerver/tests/test_message_send.py | 368 +++++++++++++++++++++++++++++- zerver/tests/test_messages.py | 355 +--------------------------- 2 files changed, 367 insertions(+), 356 deletions(-) diff --git a/zerver/tests/test_message_send.py b/zerver/tests/test_message_send.py index df0c2a7fe2..d4d0c54bd0 100644 --- a/zerver/tests/test_message_send.py +++ b/zerver/tests/test_message_send.py @@ -1,5 +1,6 @@ import datetime -from typing import Any, Optional +import time +from typing import Any, Optional, Set from unittest import mock import ujson @@ -8,23 +9,38 @@ from django.utils.timezone import now as timezone_now from zerver.decorator import JsonableError from zerver.lib.actions import ( + check_send_stream_message, + do_change_is_api_super_user, do_change_stream_post_policy, do_create_user, do_deactivate_user, + do_send_messages, do_set_realm_property, internal_send_stream_message, ) -from zerver.lib.message import get_recent_private_conversations +from zerver.lib.cache import cache_delete, get_stream_cache_key +from zerver.lib.message import MessageDict, get_raw_unread_data, get_recent_private_conversations from zerver.lib.test_classes import ZulipTestCase -from zerver.lib.test_helpers import reset_emails_in_zulip_realm +from zerver.lib.test_helpers import ( + make_client, + message_stream_count, + most_recent_message, + most_recent_usermessage, + queries_captured, + reset_emails_in_zulip_realm, +) from zerver.lib.timestamp import convert_to_UTC, datetime_to_timestamp from zerver.lib.timezone import get_timezone from zerver.models import ( MAX_MESSAGE_LENGTH, MAX_TOPIC_NAME_LENGTH, + Message, ScheduledMessage, Stream, + Subscription, + UserMessage, UserProfile, + flush_per_request_caches, get_huddle_recipient, get_realm, get_stream, @@ -1018,3 +1034,349 @@ class ScheduledMessageTest(ZulipTestCase): result = self.do_schedule_message('stream', 'Verona', content + ' 1') self.assert_json_error(result, 'Missing deliver_at in a request for delayed message delivery') + +class StreamMessagesTest(ZulipTestCase): + + def assert_stream_message(self, stream_name: str, topic_name: str="test topic", + content: str="test content") -> None: + """ + Check that messages sent to a stream reach all subscribers to that stream. + """ + realm = get_realm('zulip') + subscribers = self.users_subscribed_to_stream(stream_name, realm) + + # Outgoing webhook bots don't store UserMessage rows; they will be processed later. + subscribers = [subscriber for subscriber in subscribers + if subscriber.bot_type != UserProfile.OUTGOING_WEBHOOK_BOT] + + old_subscriber_messages = [] + for subscriber in subscribers: + old_subscriber_messages.append(message_stream_count(subscriber)) + + non_subscribers = [user_profile for user_profile in UserProfile.objects.all() + if user_profile not in subscribers] + old_non_subscriber_messages = [] + for non_subscriber in non_subscribers: + old_non_subscriber_messages.append(message_stream_count(non_subscriber)) + + non_bot_subscribers = [user_profile for user_profile in subscribers + if not user_profile.is_bot] + a_subscriber = non_bot_subscribers[0] + self.login_user(a_subscriber) + self.send_stream_message(a_subscriber, stream_name, + content=content, topic_name=topic_name) + + # Did all of the subscribers get the message? + new_subscriber_messages = [] + for subscriber in subscribers: + new_subscriber_messages.append(message_stream_count(subscriber)) + + # Did non-subscribers not get the message? + new_non_subscriber_messages = [] + for non_subscriber in non_subscribers: + new_non_subscriber_messages.append(message_stream_count(non_subscriber)) + + self.assertEqual(old_non_subscriber_messages, new_non_subscriber_messages) + self.assertEqual(new_subscriber_messages, [elt + 1 for elt in old_subscriber_messages]) + + def test_performance(self) -> None: + ''' + This test is part of the automated test suite, but + it is more intended as an aid to measuring the + performance of do_send_messages() with consistent + data setup across different commits. You can modify + the values below and run just this test, and then + comment out the print statement toward the bottom. + ''' + num_messages = 2 + num_extra_users = 10 + + sender = self.example_user('cordelia') + realm = sender.realm + message_content = 'whatever' + stream = get_stream('Denmark', realm) + topic_name = 'lunch' + recipient = stream.recipient + sending_client = make_client(name="test suite") + + for i in range(num_extra_users): + # Make every other user be idle. + long_term_idle = i % 2 > 0 + + email = f'foo{i}@example.com' + user = UserProfile.objects.create( + realm=realm, + email=email, + long_term_idle=long_term_idle, + ) + Subscription.objects.create( + user_profile=user, + recipient=recipient, + ) + + def send_test_message() -> None: + message = Message( + sender=sender, + recipient=recipient, + content=message_content, + date_sent=timezone_now(), + sending_client=sending_client, + ) + message.set_topic_name(topic_name) + do_send_messages([dict(message=message)]) + + before_um_count = UserMessage.objects.count() + + t = time.time() + for i in range(num_messages): + send_test_message() + + delay = time.time() - t + assert(delay) # quiet down lint + # print(delay) + + after_um_count = UserMessage.objects.count() + ums_created = after_um_count - before_um_count + + num_active_users = num_extra_users / 2 + self.assertTrue(ums_created > (num_active_users * num_messages)) + + def test_not_too_many_queries(self) -> None: + recipient_list = [self.example_user("hamlet"), self.example_user("iago"), + self.example_user("cordelia"), self.example_user("othello")] + for user_profile in recipient_list: + self.subscribe(user_profile, "Denmark") + + sender = self.example_user('hamlet') + sending_client = make_client(name="test suite") + stream_name = 'Denmark' + topic_name = 'foo' + content = 'whatever' + realm = sender.realm + + # To get accurate count of the queries, we should make sure that + # caches don't come into play. If we count queries while caches are + # filled, we will get a lower count. Caches are not supposed to be + # persistent, so our test can also fail if cache is invalidated + # during the course of the unit test. + flush_per_request_caches() + cache_delete(get_stream_cache_key(stream_name, realm.id)) + with queries_captured() as queries: + check_send_stream_message( + sender=sender, + client=sending_client, + stream_name=stream_name, + topic=topic_name, + body=content, + ) + + self.assert_length(queries, 14) + + def test_stream_message_dict(self) -> None: + user_profile = self.example_user('iago') + self.subscribe(user_profile, "Denmark") + self.send_stream_message(self.example_user("hamlet"), "Denmark", + content="whatever", topic_name="my topic") + message = most_recent_message(user_profile) + row = MessageDict.get_raw_db_rows([message.id])[0] + dct = MessageDict.build_dict_from_raw_db_row(row) + MessageDict.post_process_dicts([dct], apply_markdown=True, client_gravatar=False) + self.assertEqual(dct['display_recipient'], 'Denmark') + + stream = get_stream('Denmark', user_profile.realm) + self.assertEqual(dct['stream_id'], stream.id) + + def test_stream_message_unicode(self) -> None: + receiving_user_profile = self.example_user('iago') + sender = self.example_user('hamlet') + self.subscribe(receiving_user_profile, "Denmark") + self.send_stream_message(sender, "Denmark", + content="whatever", topic_name="my topic") + message = most_recent_message(receiving_user_profile) + self.assertEqual(str(message), + '>'.format(sender.email, sender.realm)) + + def test_message_mentions(self) -> None: + user_profile = self.example_user('iago') + self.subscribe(user_profile, "Denmark") + self.send_stream_message(self.example_user("hamlet"), "Denmark", + content="test @**Iago** rules") + message = most_recent_message(user_profile) + assert(UserMessage.objects.get(user_profile=user_profile, message=message).flags.mentioned.is_set) + + def test_is_private_flag(self) -> None: + user_profile = self.example_user('iago') + self.subscribe(user_profile, "Denmark") + + self.send_stream_message(self.example_user("hamlet"), "Denmark", + content="test") + message = most_recent_message(user_profile) + self.assertFalse(UserMessage.objects.get(user_profile=user_profile, message=message).flags.is_private.is_set) + + self.send_personal_message(self.example_user("hamlet"), user_profile, + content="test") + message = most_recent_message(user_profile) + self.assertTrue(UserMessage.objects.get(user_profile=user_profile, message=message).flags.is_private.is_set) + + def _send_stream_message(self, user: UserProfile, stream_name: str, content: str) -> Set[int]: + with mock.patch('zerver.lib.actions.send_event') as m: + self.send_stream_message( + user, + stream_name, + content=content, + ) + self.assertEqual(m.call_count, 1) + users = m.call_args[0][2] + user_ids = {u['id'] for u in users} + return user_ids + + def test_unsub_mention(self) -> None: + cordelia = self.example_user('cordelia') + hamlet = self.example_user('hamlet') + + stream_name = 'Test Stream' + + self.subscribe(hamlet, stream_name) + + UserMessage.objects.filter( + user_profile=cordelia, + ).delete() + + def mention_cordelia() -> Set[int]: + content = 'test @**Cordelia Lear** rules' + + user_ids = self._send_stream_message( + user=hamlet, + stream_name=stream_name, + content=content, + ) + return user_ids + + def num_cordelia_messages() -> int: + return UserMessage.objects.filter( + user_profile=cordelia, + ).count() + + user_ids = mention_cordelia() + self.assertEqual(0, num_cordelia_messages()) + self.assertNotIn(cordelia.id, user_ids) + + # Make sure test isn't too brittle-subscribing + # Cordelia and mentioning her should give her a + # message. + self.subscribe(cordelia, stream_name) + user_ids = mention_cordelia() + self.assertIn(cordelia.id, user_ids) + self.assertEqual(1, num_cordelia_messages()) + + def test_message_bot_mentions(self) -> None: + cordelia = self.example_user('cordelia') + hamlet = self.example_user('hamlet') + realm = hamlet.realm + + stream_name = 'Test Stream' + + self.subscribe(hamlet, stream_name) + + normal_bot = do_create_user( + email='normal-bot@zulip.com', + password='', + realm=realm, + full_name='Normal Bot', + short_name='', + bot_type=UserProfile.DEFAULT_BOT, + bot_owner=cordelia, + ) + + content = 'test @**Normal Bot** rules' + + user_ids = self._send_stream_message( + user=hamlet, + stream_name=stream_name, + content=content, + ) + + self.assertIn(normal_bot.id, user_ids) + user_message = most_recent_usermessage(normal_bot) + self.assertEqual(user_message.message.content, content) + self.assertTrue(user_message.flags.mentioned) + + def test_stream_message_mirroring(self) -> None: + user = self.mit_user('starnine') + self.subscribe(user, 'Verona') + + do_change_is_api_super_user(user, True) + result = self.api_post(user, "/api/v1/messages", {"type": "stream", + "to": "Verona", + "sender": self.mit_email("sipbtest"), + "client": "zephyr_mirror", + "topic": "announcement", + "content": "Everyone knows Iago rules", + "forged": "true"}, + subdomain="zephyr") + self.assert_json_success(result) + + do_change_is_api_super_user(user, False) + result = self.api_post(user, "/api/v1/messages", {"type": "stream", + "to": "Verona", + "sender": self.mit_email("sipbtest"), + "client": "zephyr_mirror", + "topic": "announcement", + "content": "Everyone knows Iago rules", + "forged": "true"}, + subdomain="zephyr") + self.assert_json_error(result, "User not authorized for this query") + + def test_message_to_stream(self) -> None: + """ + If you send a message to a stream, everyone subscribed to the stream + receives the messages. + """ + self.assert_stream_message("Scotland") + + def test_non_ascii_stream_message(self) -> None: + """ + Sending a stream message containing non-ASCII characters in the stream + name, topic, or message body succeeds. + """ + self.login('hamlet') + + # Subscribe everyone to a stream with non-ASCII characters. + non_ascii_stream_name = "hümbüǵ" + realm = get_realm("zulip") + stream = self.make_stream(non_ascii_stream_name) + for user_profile in UserProfile.objects.filter(is_active=True, is_bot=False, + realm=realm)[0:3]: + self.subscribe(user_profile, stream.name) + + self.assert_stream_message(non_ascii_stream_name, topic_name="hümbüǵ", + content="hümbüǵ") + + def test_get_raw_unread_data_for_huddle_messages(self) -> None: + users = [ + self.example_user('hamlet'), + self.example_user('cordelia'), + self.example_user('iago'), + self.example_user('prospero'), + self.example_user('othello'), + ] + + message1_id = self.send_huddle_message(users[0], users, "test content 1") + message2_id = self.send_huddle_message(users[0], users, "test content 2") + + msg_data = get_raw_unread_data(users[1]) + + # both the messages are present in msg_data + self.assertIn(message1_id, msg_data["huddle_dict"].keys()) + self.assertIn(message2_id, msg_data["huddle_dict"].keys()) + + # only these two messages are present in msg_data + self.assertEqual(len(msg_data["huddle_dict"].keys()), 2) + + recent_conversations = get_recent_private_conversations(users[1]) + self.assertEqual(len(recent_conversations), 1) + recent_conversation = list(recent_conversations.values())[0] + self.assertEqual(set(recent_conversation['user_ids']), {user.id for user in users if + user != users[1]}) + self.assertEqual(recent_conversation['max_message_id'], message2_id) diff --git a/zerver/tests/test_messages.py b/zerver/tests/test_messages.py index 7ee2e72ff5..fe8eda1d8e 100644 --- a/zerver/tests/test_messages.py +++ b/zerver/tests/test_messages.py @@ -1,6 +1,6 @@ import datetime import time -from typing import Any, Dict, List, Set, Union +from typing import Any, Dict, List, Union from unittest import mock import ujson @@ -15,13 +15,10 @@ from analytics.models import RealmCount from zerver.decorator import JsonableError from zerver.lib.actions import ( check_message, - check_send_stream_message, do_add_alert_words, - do_change_is_api_super_user, do_change_stream_invite_only, do_claim_attachments, do_create_user, - do_send_messages, do_set_realm_property, do_update_message, extract_private_recipients, @@ -39,15 +36,13 @@ from zerver.lib.actions import ( send_rate_limited_pm_notification_to_bot_owner, ) from zerver.lib.addressee import Addressee -from zerver.lib.cache import cache_delete, get_stream_cache_key, to_dict_cache_key_id +from zerver.lib.cache import cache_delete, to_dict_cache_key_id from zerver.lib.markdown import MentionData from zerver.lib.markdown import version as markdown_version from zerver.lib.message import ( MessageDict, bulk_access_messages, get_first_visible_message_id, - get_raw_unread_data, - get_recent_private_conversations, maybe_update_first_visible_message_id, messages_for_ids, render_markdown, @@ -651,352 +646,6 @@ class PersonalMessagesTest(ZulipTestCase): content="hümbüǵ", ) -class StreamMessagesTest(ZulipTestCase): - - def assert_stream_message(self, stream_name: str, topic_name: str="test topic", - content: str="test content") -> None: - """ - Check that messages sent to a stream reach all subscribers to that stream. - """ - realm = get_realm('zulip') - subscribers = self.users_subscribed_to_stream(stream_name, realm) - - # Outgoing webhook bots don't store UserMessage rows; they will be processed later. - subscribers = [subscriber for subscriber in subscribers - if subscriber.bot_type != UserProfile.OUTGOING_WEBHOOK_BOT] - - old_subscriber_messages = [] - for subscriber in subscribers: - old_subscriber_messages.append(message_stream_count(subscriber)) - - non_subscribers = [user_profile for user_profile in UserProfile.objects.all() - if user_profile not in subscribers] - old_non_subscriber_messages = [] - for non_subscriber in non_subscribers: - old_non_subscriber_messages.append(message_stream_count(non_subscriber)) - - non_bot_subscribers = [user_profile for user_profile in subscribers - if not user_profile.is_bot] - a_subscriber = non_bot_subscribers[0] - self.login_user(a_subscriber) - self.send_stream_message(a_subscriber, stream_name, - content=content, topic_name=topic_name) - - # Did all of the subscribers get the message? - new_subscriber_messages = [] - for subscriber in subscribers: - new_subscriber_messages.append(message_stream_count(subscriber)) - - # Did non-subscribers not get the message? - new_non_subscriber_messages = [] - for non_subscriber in non_subscribers: - new_non_subscriber_messages.append(message_stream_count(non_subscriber)) - - self.assertEqual(old_non_subscriber_messages, new_non_subscriber_messages) - self.assertEqual(new_subscriber_messages, [elt + 1 for elt in old_subscriber_messages]) - - def test_performance(self) -> None: - ''' - This test is part of the automated test suite, but - it is more intended as an aid to measuring the - performance of do_send_messages() with consistent - data setup across different commits. You can modify - the values below and run just this test, and then - comment out the print statement toward the bottom. - ''' - num_messages = 2 - num_extra_users = 10 - - sender = self.example_user('cordelia') - realm = sender.realm - message_content = 'whatever' - stream = get_stream('Denmark', realm) - topic_name = 'lunch' - recipient = stream.recipient - sending_client = make_client(name="test suite") - - for i in range(num_extra_users): - # Make every other user be idle. - long_term_idle = i % 2 > 0 - - email = f'foo{i}@example.com' - user = UserProfile.objects.create( - realm=realm, - email=email, - long_term_idle=long_term_idle, - ) - Subscription.objects.create( - user_profile=user, - recipient=recipient, - ) - - def send_test_message() -> None: - message = Message( - sender=sender, - recipient=recipient, - content=message_content, - date_sent=timezone_now(), - sending_client=sending_client, - ) - message.set_topic_name(topic_name) - do_send_messages([dict(message=message)]) - - before_um_count = UserMessage.objects.count() - - t = time.time() - for i in range(num_messages): - send_test_message() - - delay = time.time() - t - assert(delay) # quiet down lint - # print(delay) - - after_um_count = UserMessage.objects.count() - ums_created = after_um_count - before_um_count - - num_active_users = num_extra_users / 2 - self.assertTrue(ums_created > (num_active_users * num_messages)) - - def test_not_too_many_queries(self) -> None: - recipient_list = [self.example_user("hamlet"), self.example_user("iago"), - self.example_user("cordelia"), self.example_user("othello")] - for user_profile in recipient_list: - self.subscribe(user_profile, "Denmark") - - sender = self.example_user('hamlet') - sending_client = make_client(name="test suite") - stream_name = 'Denmark' - topic_name = 'foo' - content = 'whatever' - realm = sender.realm - - # To get accurate count of the queries, we should make sure that - # caches don't come into play. If we count queries while caches are - # filled, we will get a lower count. Caches are not supposed to be - # persistent, so our test can also fail if cache is invalidated - # during the course of the unit test. - flush_per_request_caches() - cache_delete(get_stream_cache_key(stream_name, realm.id)) - with queries_captured() as queries: - check_send_stream_message( - sender=sender, - client=sending_client, - stream_name=stream_name, - topic=topic_name, - body=content, - ) - - self.assert_length(queries, 14) - - def test_stream_message_dict(self) -> None: - user_profile = self.example_user('iago') - self.subscribe(user_profile, "Denmark") - self.send_stream_message(self.example_user("hamlet"), "Denmark", - content="whatever", topic_name="my topic") - message = most_recent_message(user_profile) - row = MessageDict.get_raw_db_rows([message.id])[0] - dct = MessageDict.build_dict_from_raw_db_row(row) - MessageDict.post_process_dicts([dct], apply_markdown=True, client_gravatar=False) - self.assertEqual(dct['display_recipient'], 'Denmark') - - stream = get_stream('Denmark', user_profile.realm) - self.assertEqual(dct['stream_id'], stream.id) - - def test_stream_message_unicode(self) -> None: - receiving_user_profile = self.example_user('iago') - sender = self.example_user('hamlet') - self.subscribe(receiving_user_profile, "Denmark") - self.send_stream_message(sender, "Denmark", - content="whatever", topic_name="my topic") - message = most_recent_message(receiving_user_profile) - self.assertEqual(str(message), - '>'.format(sender.email, sender.realm)) - - def test_message_mentions(self) -> None: - user_profile = self.example_user('iago') - self.subscribe(user_profile, "Denmark") - self.send_stream_message(self.example_user("hamlet"), "Denmark", - content="test @**Iago** rules") - message = most_recent_message(user_profile) - assert(UserMessage.objects.get(user_profile=user_profile, message=message).flags.mentioned.is_set) - - def test_is_private_flag(self) -> None: - user_profile = self.example_user('iago') - self.subscribe(user_profile, "Denmark") - - self.send_stream_message(self.example_user("hamlet"), "Denmark", - content="test") - message = most_recent_message(user_profile) - self.assertFalse(UserMessage.objects.get(user_profile=user_profile, message=message).flags.is_private.is_set) - - self.send_personal_message(self.example_user("hamlet"), user_profile, - content="test") - message = most_recent_message(user_profile) - self.assertTrue(UserMessage.objects.get(user_profile=user_profile, message=message).flags.is_private.is_set) - - def _send_stream_message(self, user: UserProfile, stream_name: str, content: str) -> Set[int]: - with mock.patch('zerver.lib.actions.send_event') as m: - self.send_stream_message( - user, - stream_name, - content=content, - ) - self.assertEqual(m.call_count, 1) - users = m.call_args[0][2] - user_ids = {u['id'] for u in users} - return user_ids - - def test_unsub_mention(self) -> None: - cordelia = self.example_user('cordelia') - hamlet = self.example_user('hamlet') - - stream_name = 'Test Stream' - - self.subscribe(hamlet, stream_name) - - UserMessage.objects.filter( - user_profile=cordelia, - ).delete() - - def mention_cordelia() -> Set[int]: - content = 'test @**Cordelia Lear** rules' - - user_ids = self._send_stream_message( - user=hamlet, - stream_name=stream_name, - content=content, - ) - return user_ids - - def num_cordelia_messages() -> int: - return UserMessage.objects.filter( - user_profile=cordelia, - ).count() - - user_ids = mention_cordelia() - self.assertEqual(0, num_cordelia_messages()) - self.assertNotIn(cordelia.id, user_ids) - - # Make sure test isn't too brittle-subscribing - # Cordelia and mentioning her should give her a - # message. - self.subscribe(cordelia, stream_name) - user_ids = mention_cordelia() - self.assertIn(cordelia.id, user_ids) - self.assertEqual(1, num_cordelia_messages()) - - def test_message_bot_mentions(self) -> None: - cordelia = self.example_user('cordelia') - hamlet = self.example_user('hamlet') - realm = hamlet.realm - - stream_name = 'Test Stream' - - self.subscribe(hamlet, stream_name) - - normal_bot = do_create_user( - email='normal-bot@zulip.com', - password='', - realm=realm, - full_name='Normal Bot', - short_name='', - bot_type=UserProfile.DEFAULT_BOT, - bot_owner=cordelia, - ) - - content = 'test @**Normal Bot** rules' - - user_ids = self._send_stream_message( - user=hamlet, - stream_name=stream_name, - content=content, - ) - - self.assertIn(normal_bot.id, user_ids) - user_message = most_recent_usermessage(normal_bot) - self.assertEqual(user_message.message.content, content) - self.assertTrue(user_message.flags.mentioned) - - def test_stream_message_mirroring(self) -> None: - user = self.mit_user('starnine') - self.subscribe(user, 'Verona') - - do_change_is_api_super_user(user, True) - result = self.api_post(user, "/api/v1/messages", {"type": "stream", - "to": "Verona", - "sender": self.mit_email("sipbtest"), - "client": "zephyr_mirror", - "topic": "announcement", - "content": "Everyone knows Iago rules", - "forged": "true"}, - subdomain="zephyr") - self.assert_json_success(result) - - do_change_is_api_super_user(user, False) - result = self.api_post(user, "/api/v1/messages", {"type": "stream", - "to": "Verona", - "sender": self.mit_email("sipbtest"), - "client": "zephyr_mirror", - "topic": "announcement", - "content": "Everyone knows Iago rules", - "forged": "true"}, - subdomain="zephyr") - self.assert_json_error(result, "User not authorized for this query") - - def test_message_to_stream(self) -> None: - """ - If you send a message to a stream, everyone subscribed to the stream - receives the messages. - """ - self.assert_stream_message("Scotland") - - def test_non_ascii_stream_message(self) -> None: - """ - Sending a stream message containing non-ASCII characters in the stream - name, topic, or message body succeeds. - """ - self.login('hamlet') - - # Subscribe everyone to a stream with non-ASCII characters. - non_ascii_stream_name = "hümbüǵ" - realm = get_realm("zulip") - stream = self.make_stream(non_ascii_stream_name) - for user_profile in UserProfile.objects.filter(is_active=True, is_bot=False, - realm=realm)[0:3]: - self.subscribe(user_profile, stream.name) - - self.assert_stream_message(non_ascii_stream_name, topic_name="hümbüǵ", - content="hümbüǵ") - - def test_get_raw_unread_data_for_huddle_messages(self) -> None: - users = [ - self.example_user('hamlet'), - self.example_user('cordelia'), - self.example_user('iago'), - self.example_user('prospero'), - self.example_user('othello'), - ] - - message1_id = self.send_huddle_message(users[0], users, "test content 1") - message2_id = self.send_huddle_message(users[0], users, "test content 2") - - msg_data = get_raw_unread_data(users[1]) - - # both the messages are present in msg_data - self.assertIn(message1_id, msg_data["huddle_dict"].keys()) - self.assertIn(message2_id, msg_data["huddle_dict"].keys()) - - # only these two messages are present in msg_data - self.assertEqual(len(msg_data["huddle_dict"].keys()), 2) - - recent_conversations = get_recent_private_conversations(users[1]) - self.assertEqual(len(recent_conversations), 1) - recent_conversation = list(recent_conversations.values())[0] - self.assertEqual(set(recent_conversation['user_ids']), {user.id for user in users if - user != users[1]}) - self.assertEqual(recent_conversation['max_message_id'], message2_id) - class MessageDictTest(ZulipTestCase): def test_both_codepaths(self) -> None: '''