ui: Add starred message count.

Initial Count Rendering:
1. get_starred function in model.py gets list of
starred messages from zulip and updates the index.
2. get_starred is called in _update_initial_data
on line 564 in model.py. I assume this function
runs at the beginning when ZT is started and that's
it. Or does it run throughout?
3. In buttons.py line 146 the StarredButton now
accepts count as an arguement.
4. In views, I set the initial count by taking the
length of model.index['starred_msg_ids']

Updating the Count Throughout the Session:
2. In _handle_message_flags_event (model.py #1133)
starred_button's count is updated to reflect that
latest changes. I have some questions about whether
this was implemented properly.

Theme:
Add new starred_count item for styling. Style for
various themes.

Tests:
Add test to check the new starred_button setup and the new model changes.

Fixes #578.

Author: klfoulk16

tests/conftest.py

@@ -547,6 +547,7 @@ def initial_data(logged_on_user, users_fixture, streams_fixture):
         # adding extra tests unnecessarily.
         'zulip_version': MINIMUM_SUPPORTED_SERVER_VERSION[0],
         'zulip_feature_level': MINIMUM_SUPPORTED_SERVER_VERSION[1],
+        'starred_messages': [1117554, 1117558, 1117574],
     }
 
 

tests/model/test_model.py

@@ -177,6 +177,7 @@ def test_register_initial_desired_events(self, mocker, initial_data):
             'presence',
             'subscription',
             'message',
+            'starred_messages',
             'update_message_flags',
             'muted_topics',
             'realm_user',
@@ -1466,6 +1467,7 @@ def test_update_star_status_no_index(self, mocker, model,
         assert model.index == dict(messages={})
         model._update_rendered_view.assert_not_called()
         set_count.assert_not_called()
+        self.controller.view.starred_button.update_count.assert_not_called()
 
     def test_update_star_status_invalid_operation(
             self, mocker, model, update_message_flags_operation,
@@ -1486,6 +1488,7 @@ def test_update_star_status_invalid_operation(
             model._handle_update_message_flags_event(event)
         model._update_rendered_view.assert_not_called()
         set_count.assert_not_called()
+        self.controller.view.starred_button.update_count.assert_not_called()
 
     @pytest.mark.parametrize('event_message_ids, indexed_ids', [
         ([1], [1]),
@@ -1511,12 +1514,12 @@ def test_update_star_status(self, mocker, model, event_op,
                                 flags_before, flags_after,
                                 update_message_flags_operation):
         operation, model.server_feature_level = update_message_flags_operation
-
         model.index = dict(messages={msg_id: {'flags': flags_before}
                                      for msg_id in indexed_ids},
                            starred_msg_ids=set([msg_id
                                                 for msg_id in indexed_ids
                                                 if 'starred' in flags_before]))
+
         event = {
             'type': 'update_message_flags',
             'messages': event_message_ids,
@@ -1547,6 +1550,68 @@ def test_update_star_status(self, mocker, model, event_op,
 
         set_count.assert_not_called()
 
+    @pytest.mark.parametrize('event_message_ids, indexed_ids', [
+        ([1], [1]),
+        ([1, 2], [1]),
+        ([1, 2], [1, 2]),
+        ([1], [1, 2]),
+    ])
+    def test_update_star_count_in_view_remove(self, mocker, model,
+                                              event_message_ids,
+                                              indexed_ids,
+                                              update_message_flags_operation):
+        operation, model.server_feature_level = update_message_flags_operation
+        model.index = dict(messages={msg_id: {'flags': ['starred']}
+                                     for msg_id in indexed_ids},
+                           starred_msg_ids=set(indexed_ids))
+
+        event = {
+            'type': 'update_message_flags',
+            'messages': event_message_ids,
+            'flag': 'starred',
+            operation: 'remove',
+            'all': False,
+        }
+        mocker.patch('zulipterminal.model.Model._update_rendered_view')
+        set_count = mocker.patch('zulipterminal.model.set_count')
+        update_star_count = self.controller.view.starred_button.update_count
+
+        model._handle_update_message_flags_event(event)
+
+        update_star_count.assert_called_with(
+            self.controller.view.starred_button.count - 1)
+
+    @pytest.mark.parametrize('event_message_ids, indexed_ids', [
+        ([1], [1]),
+        ([1, 2], [1]),
+        ([1, 2], [1, 2]),
+        ([1], [1, 2]),
+    ])
+    def test_update_star_count_in_view_add(self, mocker, model,
+                                           event_message_ids,
+                                           indexed_ids,
+                                           update_message_flags_operation):
+        operation, model.server_feature_level = update_message_flags_operation
+        model.index = dict(messages={msg_id: {'flags': []}
+                                     for msg_id in indexed_ids},
+                           starred_msg_ids=set())
+
+        event = {
+            'type': 'update_message_flags',
+            'messages': event_message_ids,
+            'flag': 'starred',
+            operation: 'add',
+            'all': False,
+        }
+        mocker.patch('zulipterminal.model.Model._update_rendered_view')
+        set_count = mocker.patch('zulipterminal.model.set_count')
+        update_star_count = self.controller.view.starred_button.update_count
+
+        model._handle_update_message_flags_event(event)
+
+        update_star_count.assert_called_with(
+            self.controller.view.starred_button.count + 1)
+
     @pytest.mark.parametrize('event_message_ids, indexed_ids', [
         ([1], [1]),
         ([1, 2], [1]),
@@ -1573,7 +1638,10 @@ def test_update_read_status(self, mocker, model, event_op,
         operation, model.server_feature_level = update_message_flags_operation
 
         model.index = dict(messages={msg_id: {'flags': flags_before}
-                                     for msg_id in indexed_ids})
+                                     for msg_id in indexed_ids},
+                           starred_msg_ids=set([msg_id
+                                                for msg_id in indexed_ids
+                                                if 'starred' in flags_before]))
         event = {
             'type': 'update_message_flags',
             'messages': event_message_ids,

tests/ui/test_ui_tools.py

@@ -1190,6 +1190,9 @@ def mock_external_classes(self, mocker):
             },
             'all_mentions': 1,
         }
+        self.view.model.initial_data = {
+            "starred_messages": [1117554, 1117558, 1117574],
+        }
         self.view.controller = mocker.Mock()
         self.super_mock = mocker.patch(VIEWS + ".urwid.Pile.__init__")
 
@@ -1198,6 +1201,7 @@ def test_menu_view(self, mocker, width=40):
             VIEWS + ".LeftColumnView.streams_view")
         home_button = mocker.patch(VIEWS + ".HomeButton")
         pm_button = mocker.patch(VIEWS + ".PMButton")
+        starred_button = mocker.patch(VIEWS + ".StarredButton")
         mocker.patch(VIEWS + ".urwid.ListBox")
         mocker.patch(VIEWS + ".urwid.SimpleFocusListWalker")
         mocker.patch(STREAMBUTTON + ".mark_muted")
@@ -1206,6 +1210,8 @@ def test_menu_view(self, mocker, width=40):
                                             count=2, width=width)
         pm_button.assert_called_once_with(left_col_view.controller,
                                           count=0, width=width)
+        starred_button.assert_called_once_with(left_col_view.controller,
+                                               count=3, width=width)
 
     @pytest.mark.parametrize('pinned', powerset([1, 2, 99, 1000]))
     def test_streams_view(self, mocker, streams, pinned, width=40):

tests/ui_tools/test_buttons.py

@@ -6,6 +6,7 @@
 from zulipterminal.config.keys import keys_for_command
 from zulipterminal.ui_tools.buttons import (
     MessageLinkButton,
+    StarredButton,
     StreamButton,
     TopButton,
     TopicButton,
@@ -92,6 +93,60 @@ def test_text_content(self, mocker,
         assert len(text[0]) == len(expected_text) == (width - 1)
         assert text[0] == expected_text
 
+    def test_starred_arg(self, mocker):
+        """Make sure only starred_button is marked as starred"""
+        show_function = mocker.Mock()
+        assert TopButton(controller=mocker.Mock(),
+                         caption='caption',
+                         show_function=show_function,
+                         width=12,
+                         count=10,
+                         starred=True).starred is True
+        assert StarredButton(controller=mocker.Mock(),
+                             width=12,
+                             count=10,).starred is True
+        assert TopButton(controller=mocker.Mock(),
+                         caption='caption',
+                         show_function=show_function,
+                         width=12,
+                         count=10,).starred is False
+
+    def test_update_count_not_starred(self, mocker):
+        """Make sure update_count is called with correct parameters"""
+        show_function = mocker.Mock()
+        other_button = TopButton(controller=mocker.Mock(),
+                                 caption='caption',
+                                 show_function=show_function,
+                                 width=12,
+                                 count=10,)
+        other_button.update_widget = mocker.patch(TOPBUTTON + ".update_widget")
+        other_button.update_count(11)
+        assert ((('unread_count', '11'), None)
+                == other_button.update_widget.call_args[0])
+
+
+class TestStarredButton:
+    # Is this where these tests should be?
+    def test_starred_is_true(self, mocker):
+        """Make sure starred_button is marked as starred"""
+        assert StarredButton(controller=mocker.Mock(),
+                             width=12,
+                             count=10,).starred is True
+
+    def test_starred_update_count(self, mocker):
+        """Make sure update_count is called with correct parameters"""
+        starred_button = StarredButton(controller=mocker.Mock(),
+                                       width=12,
+                                       count=10,)
+        starred_button.update_widget = mocker.patch(
+            TOPBUTTON + ".update_widget")
+        starred_button.update_count(11)
+        assert ((('starred_count', '11'), None)
+                == starred_button.update_widget.call_args[0])
+        # assert starred_button.update_widget.assert_called_once_with(
+        # ('starred_count', '11'), None)
+        # ^ this wasn't working but it should, any ideas?
+
 
 class TestStreamButton:
     @pytest.mark.parametrize('is_private, expected_prefix', [

zulipterminal/config/themes.py

@@ -163,6 +163,8 @@
          None,             DEF['light_blue:bold'],    DEF['black']),
         ('unread_count',   'yellow',                  'black',
          None,             DEF['yellow'],             DEF['black']),
+        ('starred_count',   'light gray',             'black',
+         None,             DEF['light_gray'],         DEF['black']),
         ('table_head',     'white, bold',             'black',
          None,             DEF['white:bold'],         DEF['black']),
         ('filter_results', 'white',                   'dark green',
@@ -255,6 +257,8 @@
          None,             LIGHTBLUE,         BLACK),
         ('unread_count',   'yellow',          'black',
          None,             YELLOW,            BLACK),
+        ('starred_count',   'light gray',      'black',
+         None,             GRAY,              BLACK),
         ('table_head',     'white, bold',     'black',
          None,             WHITEBOLD,         BLACK),
         ('filter_results', 'black',           'light green',
@@ -314,6 +318,7 @@
         ('starred',        'light red, bold', 'white'),
         ('popup_category', 'dark gray, bold', 'light gray'),
         ('unread_count',   'dark blue, bold', 'white'),
+        ('starred_count',  'black',           'white'),
         ('table_head',     'black, bold',     'white'),
         ('filter_results', 'white',           'dark green'),
         ('edit_topic',     'white',           'dark gray'),
@@ -360,6 +365,7 @@
         ('starred',        'light red, bold', 'light blue'),
         ('popup_category', 'light gray, bold', 'light blue'),
         ('unread_count',   'yellow',          'light blue'),
+        ('starred_count',  'black',           'light blue'),
         ('table_head',     'black, bold',     'light blue'),
         ('filter_results', 'white',           'dark green'),
         ('edit_topic',     'white',           'dark blue'),

zulipterminal/model.py

@@ -94,6 +94,7 @@ def __init__(self, controller: Any) -> None:
             'presence',
             'subscription',
             'message',
+            'starred_messages',
             'update_message_flags',
             'muted_topics',
             'realm_user',  # Enables cross_realm_bots
@@ -129,7 +130,6 @@ def __init__(self, controller: Any) -> None:
         self.server_feature_level = (
             self.initial_data.get('zulip_feature_level')
         )
-
         self.users = self.get_all_users()
 
         self.stream_dict: Dict[int, Any] = {}
@@ -627,7 +627,6 @@ def get_other_subscribers_in_stream(self, stream_id: Optional[int]=None,
 
         if stream_id:
             assert self.is_user_subscribed_to_stream(stream_id)
-
             return [sub
                     for sub in self.stream_dict[stream_id]['subscribers']
                     if sub != self.user_id]
@@ -1176,19 +1175,34 @@ def _handle_update_message_flags_event(self, event: Event) -> None:
         indexed_message_ids = set(self.index['messages'])
         message_ids_to_mark = set(event['messages'])
 
+        # why do we only run this for messages already in the index?
         for message_id in message_ids_to_mark & indexed_message_ids:
             msg = self.index['messages'][message_id]
             if operation == 'add':
                 if flag_to_change not in msg['flags']:
                     msg['flags'].append(flag_to_change)
-                if flag_to_change == 'starred':
+                    if flag_to_change == 'starred':
+                        # my thought is if flag_to_change is already in
+                        # msg['flags'] then the count in view is accurate
+                        # and we should only update it if flag_to_change isn't
+                        # in msg['flags']
+                        self.controller.view.starred_button.update_count(
+                            self.controller.view.starred_button.count + 1)
+                if (message_id not in self.index['starred_msg_ids']
+                        and flag_to_change == 'starred'):
                     self.index['starred_msg_ids'].add(message_id)
             elif operation == 'remove':
                 if flag_to_change in msg['flags']:
                     msg['flags'].remove(flag_to_change)
-                if (message_id in self.index['starred_msg_ids']
-                        and flag_to_change == 'starred'):
-                    self.index['starred_msg_ids'].remove(message_id)
+                    if flag_to_change == 'starred':
+                        # my thought is if flag_to_change isn't in
+                        # msg['flags'] then the count in view is accurate
+                        # and we should only update it if flag_to_change was
+                        # in msg['flags']
+                        self.controller.view.starred_button.update_count(
+                            self.controller.view.starred_button.count - 1)
+                        if message_id in self.index['starred_msg_ids']:
+                            self.index['starred_msg_ids'].remove(message_id)
             else:
                 raise RuntimeError(event, msg['flags'])
 
@@ -1298,6 +1312,8 @@ def _register_desired_events(self, *, fetch_data: bool=False) -> str:
         if response['result'] == 'success':
             if fetch_data:
                 self.initial_data.update(response)
+                with open("alternative_initial_data.txt", "w") as file:
+                    file.write(str(self.initial_data))
             self.max_message_id = response['max_message_id']
             self.queue_id = response['queue_id']
             self.last_event_id = response['last_event_id']

zulipterminal/ui_tools/buttons.py

@@ -31,6 +31,7 @@ def __init__(
         prefix_character: Union[str, Tuple[Any, str]]='\N{BULLET}',
         text_color: Optional[str]=None,
         count: int=0,
+        starred: Optional[bool]=False,
     ) -> None:
         if isinstance(prefix_character, tuple):
             prefix = prefix_character[1]
@@ -41,6 +42,7 @@ def __init__(
         self.prefix_character = prefix_character
         self.post_prefix_spacing = ' ' if prefix else ''
         self.count = count
+        self.starred = starred
 
         prefix_length = 0 if prefix == '' else 2
         # Space either side, at least one space between
@@ -61,7 +63,11 @@ def update_count(self, count: int, text_color: Optional[str]=None) -> None:
             count_text = ''
         else:
             count_text = str(count)
-        self.update_widget(('unread_count', count_text), new_color)
+
+        if self.starred is True:
+            self.update_widget(('starred_count', count_text), new_color)
+        else:
+            self.update_widget(('unread_count', count_text), new_color)
 
     def update_widget(self, count_text: Tuple[str, str],
                       text_color: Optional[str]) -> Any:
@@ -151,7 +157,7 @@ def __init__(self, controller: Any, width: int, count: int=0) -> None:
 
 
 class StarredButton(TopButton):
-    def __init__(self, controller: Any, width: int) -> None:
+    def __init__(self, controller: Any, width: int, count: int=0) -> None:
         button_text = (
             f"Starred messages [{primary_key_for_command('ALL_STARRED')}]"
         )
@@ -162,7 +168,8 @@ def __init__(self, controller: Any, width: int) -> None:
             show_function=controller.narrow_to_all_starred,
             width=width,
             prefix_character='',
-            count=0,  # Starred messages are already marked read
+            count=count,  # Starred messages are already marked read
+            starred=True,
         )
 
 

zulipterminal/ui_tools/views.py

@@ -767,9 +767,10 @@ def menu_view(self) -> Any:
             count=self.model.unread_counts['all_mentions'])
 
         # Starred messages are by definition read already
+        count = len(self.model.initial_data["starred_messages"])
         self.view.starred_button = StarredButton(self.controller,
-                                                 width=self.width)
-
+                                                 width=self.width,
+                                                 count=count)
         menu_btn_list = [
             self.view.home_button,
             self.view.pm_button,