notifications: Calculate PMs/mentions settings like other settings.

Previously, we checked for the `enable_offline_email_notifications` and
`enable_offline_push_notifications` settings (which determine whether the
user will receive notifications for PMs and mentions) just before sending
notifications. This has a few problem:

1. We do not have access to all the user settings in the notification
handlers (`handle_missedmessage_emails` and `handle_push_notifications`),
and therefore, we cannot correctly determine whether the notification should
be sent. Checks like the following which existed previously, will, for
example, incorrectly not send notifications even when stream email
notifications are enabled-
```
if not receives_offline_email_notifications(user_profile):
    return
```
With this commit, we simply do not enqueue notifications if the "offline"
settings are disabled, which fixes that bug.

Additionally, this also fixes a bug with the "online push notifications"
feature, which was, if someone were to:
* turn off notifications for PMs and mentions (`enable_offline_push_notifications`)
* turn on stream push notifications (`enable_stream_push_notifications`)
* turn on "online push" (`enable_online_push_notifications`)

then, they would still receive notifications for PMs when online.
This isn't how the "online push enabled" feature is supposed to work;
it should only act as a wrapper around the other notification settings.

The buggy code was this in `handle_push_notifications`:
```
if not (
    receives_offline_push_notifications(user_profile)
    or receives_online_push_notifications(user_profile)
):
    return

    // send notifications
```

This commit removes that code, and extends our `notification_data.py` logic
to cover this case, along with tests.

2. The name for these settings is slightly misleading. They essentially
talk about "what to send notifications for" (PMs and mentions), and not
"when to send notifications" (offline). This commit improves this condition
by restricting the use of this term only to the database field, and using
clearer names everywhere else. This distinction will be important to have
non-confusing code when we implement multiple options for notifications
in the future as dropdown (never/when offline/when offline or online, etc).

3. We should ideally re-check all notification settings just before the
notifications are sent. This is especially important for email notifications,
which may be sent after a long time after the message was sent. We will
in the future add code to thoroughly re-check settings before sending
notifications in a clean manner, but temporarily not re-checking isn't
a terrible scenario either.

zerver/tests/test_event_queue.py

@@ -44,7 +44,9 @@ class MissedMessageNotificationsTest(ZulipTestCase):
         with mock_queue_publish(
             "zerver.tornado.event_queue.queue_json_publish"
         ) as mock_queue_json_publish:
-            params["private_message"] = True
+            params["user_notifications_data"] = self.create_user_notifications_data_object(
+                user_id=1, pm_push_notify=True, pm_email_notify=True
+            )
             notified = maybe_enqueue_notifications(**params)
             self.assertTrue(mock_queue_json_publish.call_count, 2)
 
@@ -62,9 +64,8 @@ class MissedMessageNotificationsTest(ZulipTestCase):
                 message_id=1,
                 acting_user_id=2,
                 user_id=3,
-                private_message=False,
-                flags=["mentioned"],
-                mentioned=True,
+                mention_push_notify=True,
+                mention_email_notify=True,
                 mentioned_user_group_id=33,
             )
             notified = maybe_enqueue_notifications(**params)
@@ -225,11 +226,35 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                private_message=True,
+                pm_email_notify=True,
+                pm_push_notify=True,
                 already_notified={"email_notified": True, "push_notified": True},
             )
         destroy_event_queue(client_descriptor.event_queue.id)
 
+        # If `enable_offline_email_notifications` is disabled, email otifications shouldn't
+        # be sent even for PMs
+        user_profile.enable_offline_email_notifications = False
+        user_profile.save()
+        client_descriptor = allocate_event_queue()
+        self.assertTrue(client_descriptor.event_queue.empty())
+        msg_id = self.send_personal_message(iago, user_profile)
+        with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
+            missedmessage_hook(user_profile.id, client_descriptor, True)
+            mock_enqueue.assert_called_once()
+            args_dict = mock_enqueue.call_args_list[0][1]
+
+            assert_maybe_enqueue_notifications_call_args(
+                args_dict=args_dict,
+                message_id=msg_id,
+                pm_email_notify=False,
+                pm_push_notify=True,
+                already_notified={"email_notified": False, "push_notified": True},
+            )
+        destroy_event_queue(client_descriptor.event_queue.id)
+        user_profile.enable_offline_email_notifications = True
+        user_profile.save()
+
         # Test the hook with a mention; this should trigger notifications
         client_descriptor = allocate_event_queue()
         self.assertTrue(client_descriptor.event_queue.empty())
@@ -244,12 +269,35 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                flags=["mentioned"],
-                mentioned=True,
+                mention_push_notify=True,
+                mention_email_notify=True,
                 already_notified={"email_notified": True, "push_notified": True},
             )
         destroy_event_queue(client_descriptor.event_queue.id)
 
+        # If `enable_offline_push_notifications` is disabled, push otifications shouldn't
+        # be sent even for mentions
+        user_profile.enable_offline_push_notifications = False
+        user_profile.save()
+        client_descriptor = allocate_event_queue()
+        self.assertTrue(client_descriptor.event_queue.empty())
+        msg_id = self.send_personal_message(iago, user_profile)
+        with mock.patch("zerver.tornado.event_queue.maybe_enqueue_notifications") as mock_enqueue:
+            missedmessage_hook(user_profile.id, client_descriptor, True)
+            mock_enqueue.assert_called_once()
+            args_dict = mock_enqueue.call_args_list[0][1]
+
+            assert_maybe_enqueue_notifications_call_args(
+                args_dict=args_dict,
+                message_id=msg_id,
+                pm_email_notify=True,
+                pm_push_notify=False,
+                already_notified={"email_notified": True, "push_notified": False},
+            )
+        destroy_event_queue(client_descriptor.event_queue.id)
+        user_profile.enable_offline_push_notifications = True
+        user_profile.save()
+
         # Test the hook with a wildcard mention; this should trigger notifications
         client_descriptor = allocate_event_queue()
         self.assertTrue(client_descriptor.event_queue.empty())
@@ -262,7 +310,6 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                flags=["wildcard_mentioned"],
                 wildcard_mention_notify=True,
                 already_notified={"email_notified": True, "push_notified": True},
             )
@@ -280,7 +327,7 @@ class MissedMessageNotificationsTest(ZulipTestCase):
 
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
-                flags=["wildcard_mentioned"],
+                wildcard_mention_notify=False,
                 message_id=msg_id,
                 already_notified={"email_notified": False, "push_notified": False},
             )
@@ -301,7 +348,7 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                flags=["wildcard_mentioned"],
+                wildcard_mention_notify=False,
                 already_notified={"email_notified": False, "push_notified": False},
             )
         destroy_event_queue(client_descriptor.event_queue.id)
@@ -325,7 +372,6 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                flags=["wildcard_mentioned"],
                 wildcard_mention_notify=True,
                 already_notified={"email_notified": True, "push_notified": True},
             )
@@ -352,8 +398,8 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                flags=["mentioned"],
-                mentioned=True,
+                mention_push_notify=True,
+                mention_email_notify=True,
                 mentioned_user_group_id=hamlet_and_cordelia.id,
                 already_notified={"email_notified": True, "push_notified": True},
             )
@@ -469,9 +515,9 @@ class MissedMessageNotificationsTest(ZulipTestCase):
             assert_maybe_enqueue_notifications_call_args(
                 args_dict=args_dict,
                 message_id=msg_id,
-                private_message=True,
                 sender_is_muted=True,
-                flags=["read"],
+                pm_email_notify=True,
+                pm_push_notify=True,
                 already_notified={"email_notified": False, "push_notified": False},
             )
         destroy_event_queue(client_descriptor.event_queue.id)