def test_update_alert_words(self) -> None: user_profile = self.example_user('hamlet') self.login_user(user_profile) result = self.client_post('/json/users/me/alert_words', {'alert_words': ujson.dumps(['ALERT'])}) content = 'this is an ALERT for you' self.send_stream_message(user_profile, "Denmark", content) self.assert_json_success(result) original_message = most_recent_message(user_profile) user_message = most_recent_usermessage(user_profile) self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_patch("/json/messages/" + str(original_message.id), { 'message_id': original_message.id, 'content': 'new ALERT for you', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'new ALERT for you') self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_patch("/json/messages/" + str(original_message.id), { 'message_id': original_message.id, 'content': 'sorry false alarm', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'sorry false alarm') self.assertNotIn('has_alert_word', user_message.flags_list())
def test_update_alert_words(self) -> None: user_profile = self.example_user('hamlet') me_email = user_profile.email self.login(me_email) result = self.client_post('/json/users/me/alert_words', {'alert_words': ujson.dumps(['ALERT'])}) content = 'this is an ALERT for you' self.send_stream_message(me_email, "Denmark", content) self.assert_json_success(result) original_message = most_recent_message(user_profile) user_message = most_recent_usermessage(user_profile) self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_patch("/json/messages/" + str(original_message.id), { 'message_id': original_message.id, 'content': 'new ALERT for you', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'new ALERT for you') self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_patch("/json/messages/" + str(original_message.id), { 'message_id': original_message.id, 'content': 'sorry false alarm', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'sorry false alarm') self.assertNotIn('has_alert_word', user_message.flags_list())
def test_mentions(self) -> None: cordelia = self.example_user('cordelia') hamlet = self.example_user('hamlet') othello = self.example_user('othello') zoe = self.example_user('ZOE') realm = cordelia.realm group_name = 'support' stream_name = 'Dev Help' content_with_group_mention = 'hey @*support* can you help us with this?' ensure_stream(realm, stream_name) all_users = {cordelia, hamlet, othello, zoe} support_team = {hamlet, zoe} sender = cordelia other_users = all_users - support_team for user in all_users: self.subscribe(user, stream_name) create_user_group( name=group_name, members=list(support_team), realm=realm, ) payload = dict( type="stream", to=stream_name, sender=sender.email, client='test suite', subject='whatever', content=content_with_group_mention, ) with mock.patch('logging.info'): result = self.api_post(sender.email, "/json/messages", payload) self.assert_json_success(result) for user in support_team: um = most_recent_usermessage(user) self.assertTrue(um.flags.mentioned) for user in other_users: um = most_recent_usermessage(user) self.assertFalse(um.flags.mentioned)
def test_mentions(self) -> None: cordelia = self.example_user('cordelia') hamlet = self.example_user('hamlet') othello = self.example_user('othello') zoe = self.example_user('ZOE') realm = cordelia.realm group_name = 'support' stream_name = 'Dev Help' content_with_group_mention = 'hey @*support* can you help us with this?' ensure_stream(realm, stream_name) all_users = {cordelia, hamlet, othello, zoe} support_team = {hamlet, zoe} sender = cordelia other_users = all_users - support_team for user in all_users: self.subscribe(user, stream_name) create_user_group( name=group_name, members=list(support_team), realm=realm, ) payload = dict( type="stream", to=stream_name, sender=sender.email, client='test suite', topic='whatever', content=content_with_group_mention, ) with mock.patch('logging.info'): result = self.api_post(sender.email, "/json/messages", payload) self.assert_json_success(result) for user in support_team: um = most_recent_usermessage(user) self.assertTrue(um.flags.mentioned) for user in other_users: um = most_recent_usermessage(user) self.assertFalse(um.flags.mentioned)
def test_mentions(self) -> None: cordelia = self.example_user("cordelia") hamlet = self.example_user("hamlet") othello = self.example_user("othello") zoe = self.example_user("ZOE") realm = cordelia.realm group_name = "support" stream_name = "Dev Help" content_with_group_mention = "hey @*support* can you help us with this?" ensure_stream(realm, stream_name) all_users = {cordelia, hamlet, othello, zoe} support_team = {hamlet, zoe} sender = cordelia other_users = all_users - support_team for user in all_users: self.subscribe(user, stream_name) create_user_group( name=group_name, members=list(support_team), realm=realm, ) payload = dict( type="stream", to=stream_name, client="test suite", topic="whatever", content=content_with_group_mention, ) result = self.api_post(sender, "/json/messages", payload) self.assert_json_success(result) for user in support_team: um = most_recent_usermessage(user) self.assertTrue(um.flags.mentioned) for user in other_users: um = most_recent_usermessage(user) self.assertFalse(um.flags.mentioned)
def message_does_alert(self, user_profile, message): # type: (UserProfile, Text) -> bool """Send a bunch of messages as othello, so Hamlet is notified""" self.send_message(self.example_email("othello"), "Denmark", Recipient.STREAM, message) user_message = most_recent_usermessage(user_profile) return 'has_alert_word' in user_message.flags_list()
def test_receive_missed_huddle_message_email_messages(self) -> None: # build dummy messages for missed messages email reply # have Othello send Iago and Cordelia a PM. Cordelia will reply via email # Iago and Othello will receive the message. email = self.example_email('othello') self.login(email) result = self.client_post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([ self.example_email('cordelia'), self.example_email('iago') ]) }) self.assert_json_success(result) user_profile = self.example_user('cordelia') usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText( 'TestMissedHuddleMessageEmailMessages Body' ) # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message[ 'Subject'] = 'TestMissedHuddleMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('cordelia') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('cordelia') process_message(incoming_valid_message) # Confirm Iago received the message. user_profile = self.example_user('iago') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('cordelia')) self.assertEqual(message.recipient.type, Recipient.HUDDLE) # Confirm Othello received the message. user_profile = self.example_user('othello') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('cordelia')) self.assertEqual(message.recipient.type, Recipient.HUDDLE)
def message_does_alert(self, user_profile: UserProfile, message: str) -> bool: """Send a bunch of messages as othello, so Hamlet is notified""" self.send_stream_message(self.example_email("othello"), "Denmark", message) user_message = most_recent_usermessage(user_profile) return 'has_alert_word' in user_message.flags_list()
def test_receive_missed_message_email_token_missing_data(self) -> None: email = self.example_email('hamlet') self.login(email) result = self.client_post("/json/messages", {"type": "private", "content": "test_receive_missed_message_email_token_missing_data", "client": "test suite", "to": self.example_email('othello')}) self.assert_json_success(result) user_profile = self.example_user('othello') usermessage = most_recent_usermessage(user_profile) mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedMessageEmailMessages Body') incoming_valid_message['Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('othello') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('othello') # We need to force redis_client.hmget to return some None values: with mock.patch('zerver.lib.email_mirror.redis_client.hmget', return_value=[None, None, None]): exception_message = '' try: process_missed_message(mm_address, incoming_valid_message, False) except ZulipEmailForwardError as e: exception_message = str(e) self.assertEqual(exception_message, 'Missing missed message address data')
def test_missed_message(self) -> None: email = self.example_email('othello') self.login(email) result = self.client_post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([ self.example_email('cordelia'), self.example_email('iago') ]) }) self.assert_json_success(result) user_profile = self.example_user('cordelia') usermessage = most_recent_usermessage(user_profile) with self.settings(EMAIL_GATEWAY_PATTERN=''): mm_address = create_missed_message_address(user_profile, usermessage.message) self.assertEqual(mm_address, FromAddress.NOREPLY)
def test_auto_subbed_to_personals(self) -> None: """ Newly created users are auto-subbed to the ability to receive personals. """ test_email = self.nonreg_email('test') self.register(test_email, "test") user_profile = self.nonreg_user('test') old_messages_count = message_stream_count(user_profile) self.send_personal_message(user_profile, user_profile) new_messages_count = message_stream_count(user_profile) self.assertEqual(new_messages_count, old_messages_count + 1) recipient = Recipient.objects.get(type_id=user_profile.id, type=Recipient.PERSONAL) message = most_recent_message(user_profile) self.assertEqual(message.recipient, recipient) with mock.patch('zerver.models.get_display_recipient', return_value='recip'): self.assertEqual( str(message), '<Message: recip / / ' '<UserProfile: {} {}>>'.format(user_profile.email, user_profile.realm)) user_message = most_recent_usermessage(user_profile) self.assertEqual( str(user_message), f'<UserMessage: recip / {user_profile.email} ([])>', )
def test_update_alert_words(self) -> None: user = self.get_user() self.login_user(user) result = self.client_post( "/json/users/me/alert_words", {"alert_words": orjson.dumps(["ALERT"]).decode()}) content = "this is an ALERT for you" self.send_stream_message(user, "Denmark", content) self.assert_json_success(result) original_message = most_recent_message(user) user_message = most_recent_usermessage(user) self.assertIn("has_alert_word", user_message.flags_list()) result = self.client_patch( "/json/messages/" + str(original_message.id), { "message_id": original_message.id, "content": "new ALERT for you", }, ) self.assert_json_success(result) user_message = most_recent_usermessage(user) self.assertEqual(user_message.message.content, "new ALERT for you") self.assertIn("has_alert_word", user_message.flags_list()) result = self.client_patch( "/json/messages/" + str(original_message.id), { "message_id": original_message.id, "content": "sorry false alarm", }, ) self.assert_json_success(result) user_message = most_recent_usermessage(user) self.assertEqual(user_message.message.content, "sorry false alarm") self.assertNotIn("has_alert_word", user_message.flags_list())
def test_receive_missed_huddle_message_email_messages(self): # build dummy messages for missed messages email reply # have Othello send Iago and Cordelia a PM. Cordelia will reply via email # Iago and Othello will receive the message. self.login("*****@*****.**") result = self.client.post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps(["*****@*****.**", "*****@*****.**"]) }) self.assert_json_success(result) user_profile = get_user_profile_by_email("*****@*****.**") usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText( 'TestMissedHuddleMessageEmailMessages Body') incoming_valid_message[ 'Subject'] = 'TestMissedHuddleMessageEmailMessages Subject' incoming_valid_message['From'] = "*****@*****.**" incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = "*****@*****.**" process_message(incoming_valid_message) # Confirm Iago received the message. user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.type, Recipient.HUDDLE) # Confirm Othello received the message. user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.type, Recipient.HUDDLE)
def test_missed_message(self) -> None: email = self.example_email('othello') self.login(email) result = self.client_post("/json/messages", {"type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([self.example_email('cordelia'), self.example_email('iago')])}) self.assert_json_success(result) user_profile = self.example_user('cordelia') usermessage = most_recent_usermessage(user_profile) with self.settings(EMAIL_GATEWAY_PATTERN=''): mm_address = create_missed_message_address(user_profile, usermessage.message) self.assertEqual(mm_address, FromAddress.NOREPLY)
def test_update_alert_words(self): # type: () -> None me_email = '*****@*****.**' user_profile = get_user_profile_by_email(me_email) self.login(me_email) result = self.client_put('/json/users/me/alert_words', {'alert_words': ujson.dumps(['ALERT'])}) content = 'this is an ALERT for you' self.send_message(me_email, "Denmark", Recipient.STREAM, content) self.assert_json_success(result) original_message = most_recent_message(user_profile) user_message = most_recent_usermessage(user_profile) self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_post("/json/update_message", { 'message_id': original_message.id, 'content': 'new ALERT for you', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'new ALERT for you') self.assertIn('has_alert_word', user_message.flags_list()) result = self.client_post("/json/update_message", { 'message_id': original_message.id, 'content': 'sorry false alarm', }) self.assert_json_success(result) user_message = most_recent_usermessage(user_profile) self.assertEqual(user_message.message.content, 'sorry false alarm') self.assertNotIn('has_alert_word', user_message.flags_list())
def send_private_message(self) -> Text: email = self.example_email('othello') self.login(email) result = self.client_post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([self.example_email('cordelia'), self.example_email('iago')]) }) self.assert_json_success(result) user_profile = self.example_user('cordelia') user_message = most_recent_usermessage(user_profile) return create_missed_message_address(user_profile, user_message.message)
def send_private_message(self) -> str: email = self.example_email('othello') self.login(email) result = self.client_post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([self.example_email('cordelia'), self.example_email('iago')]) }) self.assert_json_success(result) user_profile = self.example_user('cordelia') user_message = most_recent_usermessage(user_profile) return create_missed_message_address(user_profile, user_message.message)
def test_receive_missed_personal_message_email_messages(self): # type: () -> None # build dummy messages for missed messages email reply # have Hamlet send Othello a PM. Othello will reply via email # Hamlet will receive the message. email = self.example_email('hamlet') self.login(email) result = self.client_post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": self.example_email('othello') }) self.assert_json_success(result) user_profile = self.example_user('othello') usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText( 'TestMissedMessageEmailMessages Body' ) # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message[ 'Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('othello') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # self.login(self.example_email("hamlet")) # confirm that Hamlet got the message user_profile = self.example_user('hamlet') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('othello')) self.assertEqual(message.recipient.id, user_profile.id) self.assertEqual(message.recipient.type, Recipient.PERSONAL)
def test_receive_missed_huddle_message_email_messages(self): # type: () -> None # build dummy messages for missed messages email reply # have Othello send Iago and Cordelia a PM. Cordelia will reply via email # Iago and Othello will receive the message. email = self.example_email('othello') self.login(email) result = self.client_post("/json/messages", {"type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps([self.example_email('cordelia'), self.example_email('iago')])}) self.assert_json_success(result) user_profile = self.example_user('cordelia') usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedHuddleMessageEmailMessages Body') # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestMissedHuddleMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('cordelia') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('cordelia') process_message(incoming_valid_message) # Confirm Iago received the message. user_profile = self.example_user('iago') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('cordelia')) self.assertEqual(message.recipient.type, Recipient.HUDDLE) # Confirm Othello received the message. user_profile = self.example_user('othello') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('cordelia')) self.assertEqual(message.recipient.type, Recipient.HUDDLE)
def test_receive_missed_personal_message_email_messages(self): # build dummy messages for missed messages email reply # have Hamlet send Othello a PM. Othello will reply via email # Hamlet will receive the message. self.login("*****@*****.**") result = self.client.post( "/json/messages", { "type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": "*****@*****.**" }) self.assert_json_success(result) user_profile = get_user_profile_by_email("*****@*****.**") usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText( 'TestMissedMessageEmailMessages Body') incoming_valid_message[ 'Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = "*****@*****.**" incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = "*****@*****.**" process_message(incoming_valid_message) # self.login("*****@*****.**") # confirm that Hamlet got the message user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.id, user_profile.id) self.assertEqual(message.recipient.type, Recipient.PERSONAL)
def test_receive_missed_huddle_message_email_messages(self): # build dummy messages for missed messages email reply # have Othello send Iago and Cordelia a PM. Cordelia will reply via email # Iago and Othello will receive the message. self.login("*****@*****.**") result = self.client.post("/json/send_message", {"type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": ujson.dumps(["*****@*****.**", "*****@*****.**"])}) self.assert_json_success(result) user_profile = get_user_profile_by_email("*****@*****.**") usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedHuddleMessageEmailMessages Body') incoming_valid_message['Subject'] = 'TestMissedHuddleMessageEmailMessages Subject' incoming_valid_message['From'] = "*****@*****.**" incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = "*****@*****.**" process_message(incoming_valid_message) # Confirm Iago received the message. user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.type, Recipient.HUDDLE) # Confirm Othello received the message. user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedHuddleMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.type, Recipient.HUDDLE)
def test_receive_missed_stream_message_email_messages(self) -> None: # build dummy messages for missed messages email reply # have Hamlet send a message to stream Denmark, that Othello # will receive a missed message email about. # Othello will reply via email. # Hamlet will see the message in the stream. self.subscribe(self.example_user("hamlet"), "Denmark") self.subscribe(self.example_user("othello"), "Denmark") email = self.example_email('hamlet') self.login(email) result = self.client_post("/json/messages", {"type": "stream", "topic": "test topic", "content": "test_receive_missed_stream_message_email_messages", "client": "test suite", "to": "Denmark"}) self.assert_json_success(result) user_profile = self.example_user('othello') usermessage = most_recent_usermessage(user_profile) mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedMessageEmailMessages Body') incoming_valid_message['Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('othello') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # confirm that Hamlet got the message user_profile = self.example_user('hamlet') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('othello')) self.assertEqual(message.recipient.type, Recipient.STREAM) self.assertEqual(message.recipient.id, usermessage.message.recipient.id)
def test_receive_missed_personal_message_email_messages(self): # type: () -> None # build dummy messages for missed messages email reply # have Hamlet send Othello a PM. Othello will reply via email # Hamlet will receive the message. email = self.example_email('hamlet') self.login(email) result = self.client_post("/json/messages", {"type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": self.example_email('othello')}) self.assert_json_success(result) user_profile = self.example_user('othello') usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedMessageEmailMessages Body') # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = self.example_email('othello') incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # self.login(self.example_email("hamlet")) # confirm that Hamlet got the message user_profile = self.example_user('hamlet') message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedMessageEmailMessages Body") self.assertEqual(message.sender, self.example_user('othello')) self.assertEqual(message.recipient.id, user_profile.id) self.assertEqual(message.recipient.type, Recipient.PERSONAL)
def test_receive_missed_personal_message_email_messages(self): # build dummy messages for missed messages email reply # have Hamlet send Othello a PM. Othello will reply via email # Hamlet will receive the message. self.login("*****@*****.**") result = self.client.post("/json/send_message", {"type": "private", "content": "test_receive_missed_message_email_messages", "client": "test suite", "to": "*****@*****.**"}) self.assert_json_success(result) user_profile = get_user_profile_by_email("*****@*****.**") usermessage = most_recent_usermessage(user_profile) # we don't want to send actual emails but we do need to create and store the # token for looking up who did reply. mm_address = create_missed_message_address(user_profile, usermessage.message) incoming_valid_message = MIMEText('TestMissedMessageEmailMessages Body') incoming_valid_message['Subject'] = 'TestMissedMessageEmailMessages Subject' incoming_valid_message['From'] = "*****@*****.**" incoming_valid_message['To'] = mm_address incoming_valid_message['Reply-to'] = "*****@*****.**" process_message(incoming_valid_message) # self.login("*****@*****.**") # confirm that Hamlet got the message user_profile = get_user_profile_by_email("*****@*****.**") message = most_recent_message(user_profile) self.assertEqual(message.content, "TestMissedMessageEmailMessages Body") self.assertEqual(message.sender, get_user_profile_by_email("*****@*****.**")) self.assertEqual(message.recipient.id, user_profile.id) self.assertEqual(message.recipient.type, Recipient.PERSONAL)
def test_redact_email_address(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "errors") stream = get_stream("Denmark", user_profile.realm) # Test for a stream address: stream_to_address = encode_email_address(stream) stream_address_parts = stream_to_address.split('@') scrubbed_stream_address = 'X'*len(stream_address_parts[0]) + '@' + stream_address_parts[1] error_message = "test message {}" error_message = error_message.format(stream_to_address) expected_message = "test message {} <Address to stream id: {}>" expected_message = expected_message.format(scrubbed_stream_address, stream.id) redacted_message = redact_email_address(error_message) self.assertEqual(redacted_message, expected_message) # Test for an invalid email address: invalid_address = "invalid@testserver" error_message = "test message {}" error_message = error_message.format(invalid_address) expected_message = "test message {} <Invalid address>" expected_message = expected_message.format('XXXXXXX@testserver') redacted_message = redact_email_address(error_message) self.assertEqual(redacted_message, expected_message) # Test for a missed message address: result = self.client_post( "/json/messages", { "type": "private", "content": "test_redact_email_message", "client": "test suite", "to": ujson.dumps([self.example_email('cordelia'), self.example_email('iago')]) }) self.assert_json_success(result) cordelia_profile = self.example_user('cordelia') user_message = most_recent_usermessage(cordelia_profile) mm_address = create_missed_message_address(user_profile, user_message.message) error_message = "test message {}" error_message = error_message.format(mm_address) expected_message = "test message {} <Missed message address>" expected_message = expected_message.format('X'*34 + '@testserver') redacted_message = redact_email_address(error_message) self.assertEqual(redacted_message, expected_message) # Test if redacting correctly scrubs multiple occurrences of the address: error_message = "test message first occurrence: {} second occurrence: {}" error_message = error_message.format(stream_to_address, stream_to_address) expected_message = "test message first occurrence: {} <Address to stream id: {}>" expected_message += " second occurrence: {} <Address to stream id: {}>" expected_message = expected_message.format(scrubbed_stream_address, stream.id, scrubbed_stream_address, stream.id) redacted_message = redact_email_address(error_message) self.assertEqual(redacted_message, expected_message) # Test with EMAIL_GATEWAY_EXTRA_PATTERN_HACK: with self.settings(EMAIL_GATEWAY_EXTRA_PATTERN_HACK='@zulip.org'): stream_to_address = stream_to_address.replace('@testserver', '@zulip.org') scrubbed_stream_address = scrubbed_stream_address.replace('@testserver', '@zulip.org') error_message = "test message {}" error_message = error_message.format(stream_to_address) expected_message = "test message {} <Address to stream id: {}>" expected_message = expected_message.format(scrubbed_stream_address, stream.id) redacted_message = redact_email_address(error_message) self.assertEqual(redacted_message, expected_message)
def message_does_alert(self, user_profile, message): # type: (UserProfile, text_type) -> bool """Send a bunch of messages as othello, so Hamlet is notified""" self.send_message("*****@*****.**", "Denmark", Recipient.STREAM, message) user_message = most_recent_usermessage(user_profile) return 'has_alert_word' in user_message.flags_list()
def message_does_alert(self, user: UserProfile, message: str) -> bool: """Send a bunch of messages as othello, so our user is notified""" self.send_stream_message(self.example_user("othello"), "Denmark", message) user_message = most_recent_usermessage(user) return "has_alert_word" in user_message.flags_list()