model/views: Add Visual desktop notification checkbox in Stream Info.

This commit adds a new checkbox 'Visual desktop notification' in the
Stream settings section inside StreamInfoView. It uses subscription
from initial_data to set the initial state of the checkbox, and
henceforth events to sync its settings between ZT <-> server.

The condition for notify_user() has also been refined to interact
properly with the checkbox settings and according to the points
mentioned in issue #666.

Tests amended.
Partially Fixes #887.

Author: zee-bit

tests/model/test_model.py

@@ -994,50 +994,65 @@ def test__update_topic_index(self, topic_name, topic_order_initial,
         assert model.index['topics'][86] == topic_order_final
 
     # TODO: Ideally message_fixture would use standardized ids?
-    @pytest.mark.parametrize(['user_id', 'vary_each_msg', 'stream_setting',
-                              'types_when_notify_called'], [
+    @pytest.mark.parametrize(['user_id', 'vary_each_msg',
+                              'desktop_notification_status',
+                              'types_when_notify_called',
+                              'is_stream_muted',
+                              'is_topic_muted'], [
         (5140, {'flags': ['mentioned', 'wildcard_mentioned']}, True,
-            []),  # message_fixture sender_id is 5140
+            [], False, False),  # message_fixture sender_id is 5140
         (5179, {'flags': ['mentioned']}, False,
-            ['stream', 'private']),
+            ['stream', 'private'], False, False),
         (5179, {'flags': ['wildcard_mentioned']}, False,
-            ['stream', 'private']),
+            ['stream', 'private'], False, False),
         (5179, {'flags': []}, True,
-            ['stream']),
+            ['stream'], False, False),
         (5179, {'flags': []}, False,
-            ['private']),
+            ['private'], False, False),
+        (5140, {'flags': []}, True,
+            ['stream'], True, True),
+        (5179, {'flags': ['mentioned']}, True,
+            ['stream'], True, True),
     ], ids=[
         'not_notified_since_self_message',
         'notified_stream_and_private_since_directly_mentioned',
         'notified_stream_and_private_since_wildcard_mentioned',
         'notified_stream_since_stream_has_desktop_notifications',
         'notified_private_since_private_message',
+        'not_notified_stream_since_muted_stream',
+        'notified_muted_stream_since_directly_mentioned',
     ])
     def test_notify_users_calling_msg_type(self, mocker, model,
                                            message_fixture,
                                            user_id,
                                            vary_each_msg,
-                                           stream_setting,
-                                           types_when_notify_called):
+                                           desktop_notification_status,
+                                           types_when_notify_called,
+                                           is_stream_muted,
+                                           is_topic_muted):
         message_fixture.update(vary_each_msg)
         model.user_id = user_id
-        if 'stream_id' in message_fixture:
-            model.stream_dict.update(
-                {message_fixture['stream_id']:
-                    {'desktop_notifications': stream_setting}}
-            )
+        mocker.patch('zulipterminal.model.Model.'
+                     'is_desktop_notifications_enabled',
+                     return_value=desktop_notification_status)
+        mocker.patch('zulipterminal.model.Model.'
+                     'is_muted_stream', return_value=is_stream_muted)
+        mocker.patch('zulipterminal.model.Model.'
+                     'is_muted_topic', return_value=is_topic_muted)
         notify = mocker.patch('zulipterminal.model.notify')
 
         model.notify_user(message_fixture)
 
+        target = None
         if message_fixture['type'] in types_when_notify_called:
             who = message_fixture['type']
-            if who == 'stream':
+            if who == 'stream' and not is_stream_muted and not is_topic_muted:
                 target = 'PTEST -> Test'
             elif who == 'private':
                 target = 'you'
                 if len(message_fixture['display_recipient']) > 2:
                     target += ', Bar Bar'
+        if target is not None:
             title = f"Test Organization Name:\nFoo Foo (to {target})"
             # TODO: Test message content too?
             notify.assert_called_once_with(title, mocker.ANY)

tests/ui_tools/test_popups.py

@@ -572,6 +572,8 @@ def mock_external_classes(self, mocker, monkeypatch):
                             return_value=(64, 64))
         self.controller.model.is_muted_stream.return_value = False
         self.controller.model.is_pinned_stream.return_value = False
+        (self.controller.model.is_desktop_notifications_enabled.
+            return_value) = False
         mocker.patch(VIEWS + ".urwid.SimpleFocusListWalker", return_value=[])
         self.stream_id = 10
         self.controller.model.stream_dict = {
@@ -669,7 +671,7 @@ def test_keypress_navigation(self, mocker, widget_size,
 
     @pytest.mark.parametrize('key', (*keys_for_command('ENTER'), ' '))
     def test_checkbox_toggle_mute_stream(self, mocker, key, widget_size):
-        mute_checkbox = self.stream_info_view.widgets[7]
+        mute_checkbox = self.stream_info_view.widgets[-3]
         toggle_mute_status = self.controller.model.toggle_stream_muted_status
         stream_id = self.stream_info_view.stream_id
         size = widget_size(mute_checkbox)
@@ -680,7 +682,7 @@ def test_checkbox_toggle_mute_stream(self, mocker, key, widget_size):
 
     @pytest.mark.parametrize('key', (*keys_for_command('ENTER'), ' '))
     def test_checkbox_toggle_pin_stream(self, mocker, key, widget_size):
-        pin_checkbox = self.stream_info_view.widgets[8]
+        pin_checkbox = self.stream_info_view.widgets[-2]
         toggle_pin_status = self.controller.model.toggle_stream_pinned_status
         stream_id = self.stream_info_view.stream_id
         size = widget_size(pin_checkbox)
@@ -689,6 +691,19 @@ def test_checkbox_toggle_pin_stream(self, mocker, key, widget_size):
 
         toggle_pin_status.assert_called_once_with(stream_id)
 
+    @pytest.mark.parametrize('key', (*keys_for_command('ENTER'), ' '))
+    def test_checkbox_toggle_desktop_notification(self, mocker,
+                                                  key, widget_size):
+        desktop_notify_checkbox = self.stream_info_view.widgets[-1]
+        toggle_desktop_notify_status = (
+            self.controller.model.toggle_stream_desktop_notification)
+        stream_id = self.stream_info_view.stream_id
+        size = widget_size(desktop_notify_checkbox)
+
+        desktop_notify_checkbox.keypress(size, key)
+
+        toggle_desktop_notify_status.assert_called_once_with(stream_id)
+
 
 class TestStreamMembersView:
     @pytest.fixture(autouse=True)

zulipterminal/model.py

@@ -977,13 +977,16 @@ def notify_user(self, message: Message) -> str:
                     if recip['id'] not in (self.user_id, message['sender_id'])
                 ]
                 recipient = ', '.join(extra_targets)
-        elif message['type'] == 'stream' and (
-            {'mentioned', 'wildcard_mentioned'}.intersection(
-                set(message['flags'])
-            )
-            or self.stream_dict[message['stream_id']]['desktop_notifications']
-        ):
-            recipient = '{display_recipient} -> {subject}'.format(**message)
+        elif message['type'] == 'stream':
+            stream_id = message['stream_id']
+            if ({'mentioned', 'wildcard_mentioned'}.intersection(
+                set(message['flags']))
+                or (self.is_desktop_notifications_enabled(stream_id)
+                    and not self.is_muted_stream(stream_id)
+                    and not self.is_muted_topic(
+                        stream_id, message['subject']))):
+                recipient = '{display_recipient} -> {subject}'.format(
+                    **message)
 
         if recipient:
             return notify(f"{self.server_name}:\n"

zulipterminal/ui_tools/views.py

@@ -1140,6 +1140,12 @@ def __init__(self, controller: Any, stream_id: int) -> None:
                                         checked_symbol=CHECK_MARK)
         urwid.connect_signal(pinned_setting, 'change',
                              self.toggle_pinned_status)
+        desktop_notification = urwid.CheckBox(
+            label="Visual desktop notification",
+            state=controller.model.is_desktop_notifications_enabled(stream_id),
+            checked_symbol=CHECK_MARK)
+        urwid.connect_signal(desktop_notification, 'change',
+                             self.toggle_desktop_notification)
 
         footlinks, footlinks_width = MessageBox.footlinks_view(
             message_links=message_links,
@@ -1152,7 +1158,7 @@ def __init__(self, controller: Any, stream_id: int) -> None:
         # Add 4 to checkbox label to accommodate the checkbox itself.
         popup_width = max(popup_width, len(muted_setting.label) + 4,
                           len(pinned_setting.label) + 4, desc.pack()[0],
-                          footlinks_width)
+                          footlinks_width, len(desktop_notification.label) + 4)
         self.widgets = self.make_table_with_categories(stream_info_content,
                                                        column_widths)
 
@@ -1166,6 +1172,7 @@ def __init__(self, controller: Any, stream_id: int) -> None:
 
         self.widgets.append(muted_setting)
         self.widgets.append(pinned_setting)
+        self.widgets.append(desktop_notification)
         super().__init__(controller, self.widgets, 'STREAM_DESC', popup_width,
                          title)
 
@@ -1175,6 +1182,11 @@ def toggle_mute_status(self, button: Any, new_state: bool) -> None:
     def toggle_pinned_status(self, button: Any, new_state: bool) -> None:
         self.controller.model.toggle_stream_pinned_status(self.stream_id)
 
+    def toggle_desktop_notification(self, button: Any,
+                                    new_state: bool) -> None:
+        self.controller.model.toggle_stream_desktop_notification(
+            self.stream_id)
+
     def keypress(self, size: urwid_Size, key: str) -> str:
         if is_command_key('STREAM_MEMBERS', key):
             self.controller.show_stream_members(stream_id=self.stream_id)