message: Consider unsubscribed channels in reconcileMessages

This fixes the "fourth buggy behavior" in #1798:
  #1798 (comment)

Fixes-partly: #1798

Author: chrisbobbe

lib/model/message.dart

@@ -410,21 +410,37 @@ class MessageStoreImpl extends HasChannelStore with MessageStore, _OutboxMessage
     //
     // If the fetched message reflects changes we haven't yet heard from the
     // event queue, then it doesn't much matter which version we use: we'll
-    // soon get the corresponding events and apply the changes anyway.
+    // soon get the corresponding events and apply the changes anyway. [1]
     // But if it lacks changes we've already heard from the event queue, then
     // we won't hear those events again; the only way to wind up with an
     // updated message is to use the version we have, that already reflects
-    // those events' changes.  So we always stick with the version we have.
+    // those events' changes.  So we always stick with the version we have. [2]
+    //
+    // [1] Actually, we don't expect an event if the message is in an
+    //     unsubscribed channel. See [2] and issue #1798 ("fourth buggy behavior").
+    // [2] Since we don't expect events for messages in unsubscribed channels,
+    //     we actually stick with the *fetched* version of those messages,
+    //     since fetching is the only reliable way to get updates.
     for (int i = 0; i < messages.length; i++) {
       final message = messages[i];
+
+      if (message is StreamMessage && subscriptions[message.streamId] == null) {
+        this.messages[message.id] = _stripMatchFields(message);
+        continue;
+      }
+
       messages[i] = this.messages.putIfAbsent(message.id, () {
-        message.matchContent = null;
-        message.matchTopic = null;
-        return message;
+        return _stripMatchFields(message);
       });
     }
   }
 
+  Message _stripMatchFields(Message message) {
+    message.matchContent = null;
+    message.matchTopic = null;
+    return message;
+  }
+
   @override
   bool? getEditMessageErrorStatus(int messageId) {
     assert(!_disposed);

test/model/message_test.dart

@@ -533,19 +533,31 @@ void main() {
       });
     });
 
-    test('on ID collision, new message does not clobber old in store.messages', () async {
-      await prepare();
-      final message = eg.streamMessage(id: 1, content: '<p>foo</p>');
-      await addMessages([message]);
-      check(store.messages).deepEquals({1: message});
-      final newMessage = eg.streamMessage(id: 1, content: '<p>bar</p>');
-      final messages = [newMessage];
-      store.reconcileMessages(messages);
-      check(messages).deepEquals(
-        // (We'll check more messages in an upcoming commit.)
-        [message].map(conditionIdentical));
-      check(store.messages).deepEquals({1: message});
-    });
+    test(
+      'on fetched message with ID already in store.messages, '
+      'fetched does not clobber existing except in unsubscribed channel',
+      () async {
+        await prepare();
+
+        final otherChannel = eg.stream();
+        await store.addStream(otherChannel);
+        check(store.subscriptions[otherChannel.streamId]).isNull();
+
+        final message1 = eg.streamMessage(id: 1, content: '<p>foo</p>');
+        final message2 = eg.streamMessage(id: 2, content: '<p>foo</p>', stream: otherChannel);
+        final message3 = eg.streamMessage(id: 3, content: '<p>foo</p>');
+        await addMessages([message1, message2, message3]);
+        check(store.messages).deepEquals({1: message1, 2: message2, 3: message3});
+        final newMessage1 = eg.streamMessage(id: 1, content: '<p>bar</p>');
+        final newMessage2 = eg.streamMessage(id: 2, content: '<p>bar</p>', stream: otherChannel);
+        final newMessage3 = eg.streamMessage(id: 3, content: '<p>bar</p>');
+        final messages = [newMessage1, newMessage2, newMessage3];
+        store.reconcileMessages(messages);
+        check(messages).deepEquals(
+          [message1, newMessage2, message3].map(conditionIdentical));
+        check(store.messages)
+          .deepEquals({1: message1, 2: newMessage2, 3: message3});
+      });
 
     test('matchContent and matchTopic are removed', () async {
       await prepare();