from unittest import mock from django.utils.timezone import now as timezone_now from zerver.lib.actions import do_add_alert_words from zerver.lib.soft_deactivation import ( add_missing_messages, do_auto_soft_deactivate_users, do_catch_up_soft_deactivated_users, do_soft_activate_users, do_soft_deactivate_user, do_soft_deactivate_users, get_soft_deactivated_users_for_catch_up, get_users_for_soft_deactivation, reactivate_user_if_soft_deactivated, ) from zerver.lib.test_classes import ZulipTestCase from zerver.lib.test_helpers import ( get_subscription, get_user_messages, make_client, queries_captured, ) from zerver.models import ( Client, Message, RealmAuditLog, Stream, UserActivity, UserMessage, UserProfile, get_realm, get_stream, ) class UserSoftDeactivationTests(ZulipTestCase): def test_do_soft_deactivate_user(self) -> None: user = self.example_user('hamlet') self.assertFalse(user.long_term_idle) with mock.patch('logging.info'): do_soft_deactivate_user(user) user.refresh_from_db() self.assertTrue(user.long_term_idle) def test_do_soft_deactivate_users(self) -> None: users = [ self.example_user('hamlet'), self.example_user('iago'), self.example_user('cordelia'), ] for user in users: self.assertFalse(user.long_term_idle) # We are sending this message to ensure that users have at least # one UserMessage row. self.send_huddle_message(users[0], users) with mock.patch('logging.info'): do_soft_deactivate_users(users) for user in users: user.refresh_from_db() self.assertTrue(user.long_term_idle) def test_get_users_for_soft_deactivation(self) -> None: users = [ self.example_user('hamlet'), self.example_user('iago'), self.example_user('cordelia'), self.example_user('ZOE'), self.example_user('othello'), self.example_user('prospero'), self.example_user('aaron'), self.example_user('polonius'), self.example_user('desdemona'), ] client, _ = Client.objects.get_or_create(name='website') query = '/some/random/endpoint' last_visit = timezone_now() count = 150 for user_profile in UserProfile.objects.all(): UserActivity.objects.get_or_create( user_profile=user_profile, client=client, query=query, count=count, last_visit=last_visit, ) filter_kwargs = dict(user_profile__realm=get_realm('zulip')) users_to_deactivate = get_users_for_soft_deactivation(-1, filter_kwargs) self.assert_length(users_to_deactivate, 9) for user in users_to_deactivate: self.assertTrue(user in users) def test_do_soft_activate_users(self) -> None: users = [ self.example_user('hamlet'), self.example_user('iago'), self.example_user('cordelia'), ] self.send_huddle_message(users[0], users) with mock.patch('logging.info'): do_soft_deactivate_users(users) for user in users: self.assertTrue(user.long_term_idle) with mock.patch('logging.info'): do_soft_activate_users(users) for user in users: user.refresh_from_db() self.assertFalse(user.long_term_idle) def test_get_users_for_catch_up(self) -> None: users = [ self.example_user('hamlet'), self.example_user('iago'), self.example_user('cordelia'), self.example_user('ZOE'), self.example_user('othello'), self.example_user('prospero'), self.example_user('aaron'), self.example_user('polonius'), self.example_user('desdemona'), ] for user_profile in UserProfile.objects.all(): user_profile.long_term_idle = True user_profile.save(update_fields=['long_term_idle']) filter_kwargs = dict(realm=get_realm('zulip')) users_to_catch_up = get_soft_deactivated_users_for_catch_up(filter_kwargs) self.assert_length(users_to_catch_up, 9) for user in users_to_catch_up: self.assertTrue(user in users) def test_do_catch_up_users(self) -> None: stream = 'Verona' hamlet = self.example_user('hamlet') users = [ self.example_user('iago'), self.example_user('cordelia'), ] all_users = users + [hamlet] for user in all_users: self.subscribe(user, stream) with mock.patch('logging.info'): do_soft_deactivate_users(users) for user in users: self.assertTrue(user.long_term_idle) message_id = self.send_stream_message(hamlet, stream, 'Hello world!') already_received = UserMessage.objects.filter(message_id=message_id).count() with mock.patch('logging.info'): do_catch_up_soft_deactivated_users(users) catch_up_received = UserMessage.objects.filter(message_id=message_id).count() self.assertEqual(already_received + len(users), catch_up_received) for user in users: user.refresh_from_db() self.assertTrue(user.long_term_idle) self.assertEqual(user.last_active_message_id, message_id) def test_do_auto_soft_deactivate_users(self) -> None: users = [ self.example_user('iago'), self.example_user('cordelia'), self.example_user('ZOE'), self.example_user('othello'), self.example_user('prospero'), self.example_user('aaron'), self.example_user('polonius'), self.example_user('desdemona'), ] sender = self.example_user('hamlet') realm = get_realm('zulip') stream_name = 'announce' for user in users + [sender]: self.subscribe(user, stream_name) client, _ = Client.objects.get_or_create(name='website') query = '/some/random/endpoint' last_visit = timezone_now() count = 150 for user_profile in users: UserActivity.objects.get_or_create( user_profile=user_profile, client=client, query=query, count=count, last_visit=last_visit, ) with mock.patch('logging.info'): users_deactivated = do_auto_soft_deactivate_users(-1, realm) self.assert_length(users_deactivated, len(users)) for user in users: self.assertTrue(user in users_deactivated) # Verify that deactivated users are caught up automatically message_id = self.send_stream_message(sender, stream_name) received_count = UserMessage.objects.filter(user_profile__in=users, message_id=message_id).count() self.assertEqual(0, received_count) with mock.patch('logging.info'): users_deactivated = do_auto_soft_deactivate_users(-1, realm) self.assert_length(users_deactivated, 0) # all users are already deactivated received_count = UserMessage.objects.filter(user_profile__in=users, message_id=message_id).count() self.assertEqual(len(users), received_count) # Verify that deactivated users are NOT caught up if # AUTO_CATCH_UP_SOFT_DEACTIVATED_USERS is off message_id = self.send_stream_message(sender, stream_name) received_count = UserMessage.objects.filter(user_profile__in=users, message_id=message_id).count() self.assertEqual(0, received_count) with self.settings(AUTO_CATCH_UP_SOFT_DEACTIVATED_USERS=False): with mock.patch('logging.info'): users_deactivated = do_auto_soft_deactivate_users(-1, realm) self.assert_length(users_deactivated, 0) # all users are already deactivated received_count = UserMessage.objects.filter(user_profile__in=users, message_id=message_id).count() self.assertEqual(0, received_count) class SoftDeactivationMessageTest(ZulipTestCase): def test_reactivate_user_if_soft_deactivated(self) -> None: recipient_list = [self.example_user("hamlet"), self.example_user("iago")] for user_profile in recipient_list: self.subscribe(user_profile, "Denmark") sender = self.example_user('iago') stream_name = 'Denmark' topic_name = 'foo' def last_realm_audit_log_entry(event_type: int) -> RealmAuditLog: return RealmAuditLog.objects.filter( event_type=event_type, ).order_by('-event_time')[0] long_term_idle_user = self.example_user('hamlet') # We are sending this message to ensure that long_term_idle_user has # at least one UserMessage row. self.send_stream_message(long_term_idle_user, stream_name) with self.assertLogs(level='INFO') as info_logs: do_soft_deactivate_users([long_term_idle_user]) self.assertEqual(info_logs.output, [ 'INFO:root:Soft-deactivated batch of 1 users; 0 remain to process' ]) message = 'Test Message 1' message_id = self.send_stream_message(sender, stream_name, message, topic_name) idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) self.assertNotEqual(idle_user_msg_list[-1].content, message) with queries_captured() as queries: reactivate_user_if_soft_deactivated(long_term_idle_user) self.assert_length(queries, 8) self.assertFalse(long_term_idle_user.long_term_idle) self.assertEqual(last_realm_audit_log_entry( RealmAuditLog.USER_SOFT_ACTIVATED).modified_user, long_term_idle_user) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 1) self.assertEqual(idle_user_msg_list[-1].content, message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, message_id) def test_add_missing_messages(self) -> None: recipient_list = [self.example_user("hamlet"), self.example_user("iago")] for user_profile in recipient_list: self.subscribe(user_profile, "Denmark") sender = self.example_user('iago') realm = sender.realm sending_client = make_client(name="test suite") stream_name = 'Denmark' stream = get_stream(stream_name, realm) topic_name = 'foo' def send_fake_message(message_content: str, stream: Stream) -> Message: recipient = stream.recipient message = Message(sender = sender, recipient = recipient, content = message_content, date_sent = timezone_now(), sending_client = sending_client) message.set_topic_name(topic_name) message.save() return message long_term_idle_user = self.example_user('hamlet') self.send_stream_message(long_term_idle_user, stream_name) with self.assertLogs(level='INFO') as info_logs: do_soft_deactivate_users([long_term_idle_user]) self.assertEqual(info_logs.output, [ 'INFO:root:Soft-deactivated batch of 1 users; 0 remain to process' ]) # Test that add_missing_messages() in simplest case of adding a # message for which UserMessage row doesn't exist for this user. sent_message = send_fake_message('Test Message 1', stream) idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) self.assertNotEqual(idle_user_msg_list[-1], sent_message) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 6) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 1) self.assertEqual(idle_user_msg_list[-1], sent_message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, sent_message.id) # Test that add_missing_messages() only adds messages that aren't # already present in the UserMessage table. This test works on the # fact that previous test just above this added a message but didn't # updated the last_active_message_id field for the user. sent_message = send_fake_message('Test Message 2', stream) idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) self.assertNotEqual(idle_user_msg_list[-1], sent_message) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 7) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 1) self.assertEqual(idle_user_msg_list[-1], sent_message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, sent_message.id) # Test UserMessage rows are created correctly in case of stream # Subscription was altered by admin while user was away. # Test for a public stream. sent_message_list = [] sent_message_list.append(send_fake_message('Test Message 3', stream)) # Alter subscription to stream. self.unsubscribe(long_term_idle_user, stream_name) send_fake_message('Test Message 4', stream) self.subscribe(long_term_idle_user, stream_name) sent_message_list.append(send_fake_message('Test Message 5', stream)) sent_message_list.reverse() idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) for sent_message in sent_message_list: self.assertNotEqual(idle_user_msg_list.pop(), sent_message) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 6) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 2) for sent_message in sent_message_list: self.assertEqual(idle_user_msg_list.pop(), sent_message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, sent_message_list[0].id) # Test consecutive subscribe/unsubscribe in a public stream sent_message_list = [] sent_message_list.append(send_fake_message('Test Message 6', stream)) # Unsubscribe from stream and then immediately subscribe back again. self.unsubscribe(long_term_idle_user, stream_name) self.subscribe(long_term_idle_user, stream_name) sent_message_list.append(send_fake_message('Test Message 7', stream)) # Again unsubscribe from stream and send a message. # This will make sure that if initially in a unsubscribed state # a consecutive subscribe/unsubscribe doesn't misbehave. self.unsubscribe(long_term_idle_user, stream_name) send_fake_message('Test Message 8', stream) # Do a subscribe and unsubscribe immediately. self.subscribe(long_term_idle_user, stream_name) self.unsubscribe(long_term_idle_user, stream_name) sent_message_list.reverse() idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) for sent_message in sent_message_list: self.assertNotEqual(idle_user_msg_list.pop(), sent_message) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 6) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 2) for sent_message in sent_message_list: self.assertEqual(idle_user_msg_list.pop(), sent_message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, sent_message_list[0].id) # Test for when user unsubscribes before soft deactivation # (must reactivate them in order to do this). do_soft_activate_users([long_term_idle_user]) self.subscribe(long_term_idle_user, stream_name) # Send a real message to update last_active_message_id sent_message_id = self.send_stream_message( sender, stream_name, 'Test Message 9') self.unsubscribe(long_term_idle_user, stream_name) # Soft deactivate and send another message to the unsubscribed stream. with self.assertLogs(level='INFO') as info_logs: do_soft_deactivate_users([long_term_idle_user]) self.assertEqual(info_logs.output, [ 'INFO:root:Soft-deactivated batch of 1 users; 0 remain to process' ]) send_fake_message('Test Message 10', stream) idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) self.assertEqual(idle_user_msg_list[-1].id, sent_message_id) with queries_captured() as queries: add_missing_messages(long_term_idle_user) # There are no streams to fetch missing messages from, so # the Message.objects query will be avoided. self.assert_length(queries, 4) idle_user_msg_list = get_user_messages(long_term_idle_user) # No new UserMessage rows should have been created. self.assertEqual(len(idle_user_msg_list), idle_user_msg_count) # Note: At this point in this test we have long_term_idle_user # unsubscribed from the 'Denmark' stream. # Test for a Private Stream. stream_name = "Core" private_stream = self.make_stream('Core', invite_only=True) self.subscribe(self.example_user("iago"), stream_name) sent_message_list = [] send_fake_message('Test Message 11', private_stream) self.subscribe(self.example_user("hamlet"), stream_name) sent_message_list.append(send_fake_message('Test Message 12', private_stream)) self.unsubscribe(long_term_idle_user, stream_name) send_fake_message('Test Message 13', private_stream) self.subscribe(long_term_idle_user, stream_name) sent_message_list.append(send_fake_message('Test Message 14', private_stream)) sent_message_list.reverse() idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) for sent_message in sent_message_list: self.assertNotEqual(idle_user_msg_list.pop(), sent_message) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 6) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + 2) for sent_message in sent_message_list: self.assertEqual(idle_user_msg_list.pop(), sent_message) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, sent_message_list[0].id) @mock.patch('zerver.lib.soft_deactivation.BULK_CREATE_BATCH_SIZE', 2) def test_add_missing_messages_pagination(self) -> None: recipient_list = [self.example_user("hamlet"), self.example_user("iago")] stream_name = 'Denmark' for user_profile in recipient_list: self.subscribe(user_profile, stream_name) sender = self.example_user('iago') long_term_idle_user = self.example_user('hamlet') self.send_stream_message(long_term_idle_user, stream_name) with self.assertLogs(level='INFO') as info_logs: do_soft_deactivate_users([long_term_idle_user]) self.assertEqual(info_logs.output, [ 'INFO:root:Soft-deactivated batch of 1 users; 0 remain to process' ]) num_new_messages = 5 message_ids = [] for _ in range(num_new_messages): message_id = self.send_stream_message(sender, stream_name) message_ids.append(message_id) idle_user_msg_list = get_user_messages(long_term_idle_user) idle_user_msg_count = len(idle_user_msg_list) with queries_captured() as queries: add_missing_messages(long_term_idle_user) self.assert_length(queries, 10) idle_user_msg_list = get_user_messages(long_term_idle_user) self.assertEqual(len(idle_user_msg_list), idle_user_msg_count + num_new_messages) long_term_idle_user.refresh_from_db() self.assertEqual(long_term_idle_user.last_active_message_id, message_ids[-1]) def test_user_message_filter(self) -> None: # In this test we are basically testing out the logic used out in # do_send_messages() in action.py for filtering the messages for which # UserMessage rows should be created for a soft-deactivated user. recipient_list = [ self.example_user("hamlet"), self.example_user("iago"), self.example_user('cordelia'), ] for user_profile in recipient_list: self.subscribe(user_profile, "Denmark") cordelia = self.example_user('cordelia') sender = self.example_user('iago') stream_name = 'Denmark' topic_name = 'foo' def send_stream_message(content: str) -> None: self.send_stream_message(sender, stream_name, content, topic_name) def send_personal_message(content: str) -> None: self.send_personal_message(sender, self.example_user("hamlet"), content) long_term_idle_user = self.example_user('hamlet') self.send_stream_message(long_term_idle_user, stream_name) with self.assertLogs(level='INFO') as info_logs: do_soft_deactivate_users([long_term_idle_user]) self.assertEqual(info_logs.output, [ 'INFO:root:Soft-deactivated batch of 1 users; 0 remain to process' ]) def assert_um_count(user: UserProfile, count: int) -> None: user_messages = get_user_messages(user) self.assertEqual(len(user_messages), count) def assert_last_um_content(user: UserProfile, content: str, negate: bool=False) -> None: user_messages = get_user_messages(user) if negate: self.assertNotEqual(user_messages[-1].content, content) else: self.assertEqual(user_messages[-1].content, content) # Test that sending a message to a stream with soft deactivated user # doesn't end up creating UserMessage row for deactivated user. general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test Message 1' send_stream_message(message) assert_last_um_content(long_term_idle_user, message, negate=True) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) # Test that sending a message to a stream with soft deactivated user # and push/email notifications on creates a UserMessage row for the # deactivated user. sub = get_subscription(stream_name, long_term_idle_user) sub.push_notifications = True sub.save() general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test private stream message' send_stream_message(message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_last_um_content(long_term_idle_user, message) sub.push_notifications = False sub.save() # Test sending a private message to soft deactivated user creates # UserMessage row. soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test PM' send_personal_message(message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_last_um_content(long_term_idle_user, message) # Test UserMessage row is created while user is deactivated if # user itself is mentioned. general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test @**King Hamlet** mention' send_stream_message(message) assert_last_um_content(long_term_idle_user, message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) # Test UserMessage row is not created while user is deactivated if # anyone is mentioned but the user. general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test @**Cordelia Lear** mention' send_stream_message(message) assert_last_um_content(long_term_idle_user, message, negate=True) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) # Test UserMessage row is created while user is deactivated if # there is a wildcard mention such as @all or @everyone general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test @**all** mention' send_stream_message(message) assert_last_um_content(long_term_idle_user, message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test @**everyone** mention' send_stream_message(message) assert_last_um_content(long_term_idle_user, message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Test @**stream** mention' send_stream_message(message) assert_last_um_content(long_term_idle_user, message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) # Test UserMessage row is not created while user is deactivated if there # is a alert word in message. do_add_alert_words(long_term_idle_user, ['test_alert_word']) general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = 'Testing test_alert_word' send_stream_message(message) assert_last_um_content(long_term_idle_user, message) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count + 1) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message) # Test UserMessage row is created while user is deactivated if # message is a me message. general_user_msg_count = len(get_user_messages(cordelia)) soft_deactivated_user_msg_count = len(get_user_messages(long_term_idle_user)) message = '/me says test' send_stream_message(message) assert_last_um_content(long_term_idle_user, message, negate=True) assert_um_count(long_term_idle_user, soft_deactivated_user_msg_count) assert_um_count(cordelia, general_user_msg_count + 1) assert_last_um_content(cordelia, message)