def test_reply_is_extracted_from_html(self) -> None: # build dummy messages for stream # test valid incoming stream message is processed properly email = self.example_email('hamlet') self.login(email) user_profile = self.example_user('hamlet') self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) html = """ <html> <body> <p>Reply</p> <blockquote> <div> On 11-Apr-2011, at 6:54 PM, Bob <[email protected]> wrote: </div> <div> Quote </div> </blockquote> </body> </html> """ incoming_valid_message = MIMEText(html, 'html') incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, 'Reply') # Don't extract if Subject indicates the email has been forwarded into the mirror: del incoming_valid_message['Subject'] incoming_valid_message['Subject'] = 'FWD: TestStreamEmailMessages Subject' process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual(message.content, convert_html_to_markdown(html))
def test_receive_stream_email_messages_success(self) -> None: # build dummy messages for stream # test valid incoming stream message is processed properly user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "TestStreamEmailMessages Body") self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.topic_name(), incoming_valid_message['Subject'])
def test_receive_stream_email_multiple_recipient_success(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) # stream address is angle-addr within multiple addresses stream_to_addresses = ["A.N. Other <*****@*****.**>", "Denmark <{}>".format(encode_email_address(stream))] incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = ", ".join(stream_to_addresses) incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "TestStreamEmailMessages Body") self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.topic_name(), incoming_valid_message['Subject'])
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_reply_is_extracted_from_plain(self) -> None: # build dummy messages for stream # test valid incoming stream message is processed properly email = self.example_email('hamlet') self.login(email) user_profile = self.example_user('hamlet') self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) text = """Reply -----Original Message----- Quote""" incoming_valid_message = MIMEText(text) # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "Reply")
def test_receive_stream_email_messages_success(self): # build dummy messages for stream # test valid incoming stream message is processed properly self.login("*****@*****.**") user_profile = get_user_profile_by_email("*****@*****.**") self.subscribe_to_stream(user_profile.email, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = "*****@*****.**" incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = "*****@*****.**" process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "TestStreamEmailMessages Body") self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.subject, incoming_valid_message['Subject'])
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_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_sending_a_json_fixture(self) -> None: fixture_path = "zerver/tests/fixtures/email/1.json" user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") call_command(self.COMMAND_NAME, "--fixture={}".format(fixture_path)) message = most_recent_message(user_profile) # last message should be equal to the body of the email in 1.json self.assertEqual(message.content, "Email fixture 1.json body")
def test_process_message_strips_subject(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = "Re: Fwd: Re: Test" incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual("Test", message.topic_name()) # If after stripping we get an empty subject, it should get set to (no topic) del incoming_valid_message['Subject'] incoming_valid_message['Subject'] = "Re: Fwd: Re: " process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual("(no topic)", message.topic_name())
def test_no_response_to_group_pm(self) -> None: realm = get_realm('zulip') # Assume realm is always 'zulip' user1_email = self.example_email('hamlet') user2_email = self.example_email('cordelia') bot_email = self.example_email('welcome_bot') content = "whatever" self.login(user1_email) self.send_huddle_message(user1_email, [bot_email, user2_email], content) user1 = get_user(user1_email, realm) user1_messages = message_stream_count(user1) self.assertEqual(most_recent_message(user1).content, content) # Welcome bot should still respond to initial PM after group PM. self.send_personal_message(user1_email, bot_email, content) self.assertEqual(message_stream_count(user1), user1_messages+2)
def test_reply_is_extracted_from_plain(self) -> None: # build dummy messages for stream # test valid incoming stream message is processed properly email = self.example_email('hamlet') self.login(email) user_profile = self.example_user('hamlet') self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) text = """Reply -----Original Message----- Quote""" incoming_valid_message = MIMEText(text) incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "Reply") # Don't extract if Subject indicates the email has been forwarded into the mirror: del incoming_valid_message['Subject'] incoming_valid_message['Subject'] = 'FWD: TestStreamEmailMessages Subject' process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual(message.content, text)
def test_stream_option(self) -> None: fixture_path = "zerver/tests/fixtures/email/1.txt" user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark2") call_command(self.COMMAND_NAME, "--fixture={}".format(fixture_path), "--stream=Denmark2") message = most_recent_message(user_profile) # last message should be equal to the body of the email in 1.txt self.assertEqual(message.content, "Email fixture 1.txt body") stream_id = get_stream("Denmark2", message.sender.realm).id self.assertEqual(message.recipient.type, Recipient.STREAM) self.assertEqual(message.recipient.type_id, stream_id)
def test_single_response_to_pm(self) -> None: realm = get_realm('zulip') user_email = '*****@*****.**' bot_email = '*****@*****.**' content = 'whatever' self.login(user_email) self.send_personal_message(user_email, bot_email, content) user = get_user(user_email, realm) user_messages = message_stream_count(user) expected_response = ("Congratulations on your first reply! :tada:\n\n" "Feel free to continue using this space to practice your new messaging " "skills. Or, try clicking on some of the stream names to your left!") self.assertEqual(most_recent_message(user).content, expected_response) # Welcome bot shouldn't respond to further PMs. self.send_personal_message(user_email, bot_email, content) self.assertEqual(message_stream_count(user), user_messages+1)
def test_receive_missed_personal_message_email_messages(self) -> 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_reply_is_extracted_from_html(self) -> None: # build dummy messages for stream # test valid incoming stream message is processed properly email = self.example_email('hamlet') self.login(email) user_profile = self.example_user('hamlet') self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) html = """ <html> <body> <p>Reply</p> <blockquote> <div> On 11-Apr-2011, at 6:54 PM, Bob <[email protected]> wrote: </div> <div> Quote </div> </blockquote> </body> </html> """ incoming_valid_message = MIMEText( html, 'html' ) # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, 'Reply')
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_single_response_to_pm(self) -> None: realm = get_realm('zulip') user_email = '*****@*****.**' bot_email = '*****@*****.**' content = 'whatever' self.login(user_email) self.send_personal_message(user_email, bot_email, content) user = get_user(user_email, realm) user_messages = message_stream_count(user) expected_response = ( "Congratulations on your first reply! :tada:\n\n" "Feel free to continue using this space to practice your new messaging " "skills. Or, try clicking on some of the stream names to your left!" ) self.assertEqual(most_recent_message(user).content, expected_response) # Welcome bot shouldn't respond to further PMs. self.send_personal_message(user_email, bot_email, content) self.assertEqual(message_stream_count(user), user_messages + 1)
def common_get_profile(self, user_id: str) -> Dict[str, Any]: # Assumes all users are example users in realm 'zulip' user_profile = self.example_user(user_id) self.send_stream_message(user_profile.email, "Verona", "hello") result = self.api_get(user_profile.email, "/api/v1/users/me") max_id = most_recent_message(user_profile).id self.assert_json_success(result) json = result.json() self.assertIn("client_id", json) self.assertIn("max_message_id", json) self.assertIn("pointer", json) self.assertEqual(json["max_message_id"], max_id) return json
def test_charset_not_specified(self) -> None: message_as_string = self.fixture_data('1.txt', type='email') message_as_string = message_as_string.replace("Content-Type: text/plain; charset=\"us-ascii\"", "Content-Type: text/plain") incoming_message = message_from_string(message_as_string) user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) del incoming_message['To'] incoming_message['To'] = stream_to_address process_message(incoming_message) message = most_recent_message(user_profile) self.assertEqual(message.content, "Email fixture 1.txt body")
def test_reply_is_extracted_from_html(self): # type: () -> None # build dummy messages for stream # test valid incoming stream message is processed properly email = self.example_email('hamlet') self.login(email) user_profile = self.example_user('hamlet') self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) html = """ <html> <body> <p>Reply</p> <blockquote> <div> On 11-Apr-2011, at 6:54 PM, Bob <[email protected]> wrote: </div> <div> Quote </div> </blockquote> </body> </html> """ incoming_valid_message = MIMEText(html, 'html') # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, 'Reply')
def common_get_profile(self, user_id): # type: (str) -> Dict[Text, Any] # Assumes all users are example users in realm 'zulip' user_profile = self.example_user(user_id) self.send_message(user_profile.email, "Verona", Recipient.STREAM, "hello") result = self.client_get("/api/v1/users/me", **self.api_auth(user_profile.email)) max_id = most_recent_message(user_profile).id self.assert_json_success(result) json = result.json() self.assertIn("client_id", json) self.assertIn("max_message_id", json) self.assertIn("pointer", json) self.assertEqual(json["max_message_id"], max_id) return json
def test_stream_option(self) -> None: fixture_path = "zerver/tests/fixtures/email/1.txt" user_profile = self.example_user('hamlet') self.login_user(user_profile) self.subscribe(user_profile, "Denmark2") with self.assertLogs('zerver.lib.email_mirror', level='INFO') as info_log: call_command(self.COMMAND_NAME, f"--fixture={fixture_path}", "--stream=Denmark2") self.assertEqual(info_log.output, [ 'INFO:zerver.lib.email_mirror:Successfully processed email to Denmark2 (zulip)' ]) message = most_recent_message(user_profile) # last message should be equal to the body of the email in 1.txt self.assertEqual(message.content, "Email fixture 1.txt body") stream_id = get_stream("Denmark2", get_realm("zulip")).id self.assertEqual(message.recipient.type, Recipient.STREAM) self.assertEqual(message.recipient.type_id, stream_id)
def test_sending_a_json_fixture(self) -> None: fixture_path = "zerver/tests/fixtures/email/1.json" user_profile = self.example_user("hamlet") self.login_user(user_profile) self.subscribe(user_profile, "Denmark") with self.assertLogs("zerver.lib.email_mirror", level="INFO") as info_log: call_command(self.COMMAND_NAME, f"--fixture={fixture_path}") self.assertEqual( info_log.output, [ "INFO:zerver.lib.email_mirror:Successfully processed email to Denmark (zulip)" ], ) message = most_recent_message(user_profile) # last message should be equal to the body of the email in 1.json self.assertEqual(message.content, "Email fixture 1.json body")
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_send_message(self): # type: () -> None email = '*****@*****.**' user = get_user_profile_by_email(email) self.login(email) welcome_bot = get_user_profile_by_email("*****@*****.**") raw_params = dict( type='stream', recipient='Denmark', topic='welcome', content='hello' ) params = fix_params(raw_params) result = self.client_post("/json/tutorial_send_message", params) self.assert_json_success(result) message = most_recent_message(user) self.assertEqual(message.content, 'hello') self.assertEqual(message.sender, welcome_bot) # now test some error cases result = self.client_post("/json/tutorial_send_message", {}) self.assert_json_error(result, "Missing 'type' argument") result = self.client_post("/json/tutorial_send_message", raw_params) self.assert_json_error(result, 'argument "type" is not valid json.') raw_params = dict( type='INVALID', recipient='Denmark', topic='welcome', content='hello' ) params = fix_params(raw_params) result = self.client_post("/json/tutorial_send_message", params) self.assert_json_error(result, 'Bad data passed in to tutorial_send_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_update_alert_words(self): # type: () -> 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_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_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_receive_stream_email_messages_empty_body_after_stripping(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) headers = {} headers['Reply-To'] = self.example_email('othello') # empty body incoming_valid_message = MIMEText('-- \nFooter') incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual(message.content, "(No email body)")
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_stream_email_messages_blank_subject_success(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = '' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "TestStreamEmailMessages Body") self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.topic_name(), "(no topic)")
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_update_alert_words(self) -> None: user = self.get_user() self.login_user(user) 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, "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_stream_email_show_sender_success(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) parts = stream_to_address.split('@') parts[0] += "+show-sender" stream_to_address = '@'.join(parts) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) message = most_recent_message(user_profile) self.assertEqual(message.content, "From: %s\n%s" % (self.example_email('hamlet'), "TestStreamEmailMessages Body")) self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.topic_name(), incoming_valid_message['Subject'])
def test_receive_private_stream_email_messages_success(self) -> None: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.make_stream("private_stream", invite_only=True) self.subscribe(user_profile, "private_stream") stream = get_stream("private_stream", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') # type: Any # https://github.com/python/typeshed/issues/275 incoming_valid_message['Subject'] = 'TestStreamEmailMessages Subject' incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) # Hamlet is subscribed to this stream so should see the email message from Othello. message = most_recent_message(user_profile) self.assertEqual(message.content, "TestStreamEmailMessages Body") self.assertEqual(get_display_recipient(message.recipient), stream.name) self.assertEqual(message.topic_name(), incoming_valid_message['Subject'])
def test_email_subject_stripping(self) -> None: subject_list = ujson.loads(self.fixture_data('subjects.json', type='email')) for subject in subject_list: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = subject['original_subject'] incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) message = most_recent_message(user_profile) if subject['stripped_subject'] is not "": expected_topic = subject['stripped_subject'] else: expected_topic = "(no topic)" self.assertEqual(expected_topic, message.topic_name())
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 test_email_subject_stripping(self) -> None: subject_list = ujson.loads(self.fixture_data('subjects.json', type='email')) for subject in subject_list: user_profile = self.example_user('hamlet') self.login(user_profile.email) self.subscribe(user_profile, "Denmark") stream = get_stream("Denmark", user_profile.realm) stream_to_address = encode_email_address(stream) incoming_valid_message = MIMEText('TestStreamEmailMessages Body') incoming_valid_message['Subject'] = subject['original_subject'] incoming_valid_message['From'] = self.example_email('hamlet') incoming_valid_message['To'] = stream_to_address incoming_valid_message['Reply-to'] = self.example_email('othello') process_message(incoming_valid_message) message = most_recent_message(user_profile) if subject['stripped_subject'] != "": expected_topic = subject['stripped_subject'] else: expected_topic = "(no topic)" self.assertEqual(expected_topic, message.topic_name())
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_edit_message(self) -> None: """ Verify if the time limit imposed on message editing is working correctly. """ iago = self.example_user("iago") self.login("iago") # Set limit to edit message content. MESSAGE_CONTENT_EDIT_LIMIT = 5 * 60 # 5 minutes result = self.client_patch( "/json/realm", { "allow_message_editing": "true", "message_content_edit_limit_seconds": MESSAGE_CONTENT_EDIT_LIMIT, }, ) self.assert_json_success(result) sent_message_id = self.send_stream_message( iago, "Scotland", topic_name="lunch", content="I want pizza!", ) message_sent_time = timezone_now() # Verify message sent. message = most_recent_message(iago) self.assertEqual(message.id, sent_message_id) self.assertEqual(message.content, "I want pizza!") # Edit message content now. This should work as we're editing # it immediately after sending i.e., before the limit exceeds. result = self.client_patch( f"/json/messages/{sent_message_id}", {"content": "I want burger!"} ) self.assert_json_success(result) message = most_recent_message(iago) self.assertEqual(message.id, sent_message_id) self.assertEqual(message.content, "I want burger!") # Now that we tested message editing works within the limit, # we want to verify it doesn't work beyond the limit. # # To do that we'll have to wait for the time limit to pass which is # 5 minutes here. Easy, use time.sleep() but mind that it slows down the # test to a great extent which isn't good. This is when mocking comes to rescue. # We can check what the original code does to determine whether the time limit # exceeded and mock that here such that the code runs as if the time limit # exceeded without actually waiting for that long! # # In this case, it is timezone_now, an alias to django.utils.timezone.now, # to which the difference with message-sent-time is checked. So, we want # that timezone_now() call to return `datetime` object representing time # that is beyond the limit. # # Notice how mock.patch() is used here to do exactly the above mentioned. # mock.patch() here makes any calls to `timezone_now` in `zerver.lib.actions` # to return the value passed to `return_value` in the its context. # You can also use mock.patch() as a decorator depending on the # requirements. Read more at the documentation link provided above. time_beyond_edit_limit = message_sent_time + datetime.timedelta( seconds=MESSAGE_CONTENT_EDIT_LIMIT + 100 ) # There's a buffer time applied to the limit, hence the extra 100s. with mock.patch( "zerver.lib.actions.timezone_now", return_value=time_beyond_edit_limit, ): result = self.client_patch( f"/json/messages/{sent_message_id}", {"content": "I actually want pizza."} ) self.assert_json_error(result, msg="The time limit for editing this message has passed") message = most_recent_message(iago) self.assertEqual(message.id, sent_message_id) self.assertEqual(message.content, "I want burger!")