squash? Test everything, parameterized

Signed-off-by: Zixuan James Li <[email protected]>

Author: PIG208

test/model/unreads_test.dart

@@ -470,212 +470,146 @@ void main() {
       }
     });
 
-    // For the reader:
-    // This implements tests without heavily parameterizing them;
-    // see and compare with the next commit that changes this.
     group('moves', () {
-      final origChannel = eg.stream();
+      final origChannel = eg.stream(name: 'old channel');
+      final newChannel = eg.stream(name: 'new channel');
+      final newUnsubscribedChannel = eg.stream(name: 'new unsubscribed channel');
       const origTopic = 'origTopic';
       const newTopic = 'newTopic';
 
-      Future<void> prepareStore() async {
-        prepare();
-        await channelStore.addStream(origChannel);
-        await channelStore.addSubscription(eg.subscription(origChannel));
-      }
-
-      group('move read messages', () {
-        final readMessages = List<StreamMessage>.generate(10,
-          (_) => eg.streamMessage(
-            stream: origChannel, topic: origTopic, flags: [MessageFlag.read]));
-
-        test('to new channel', () async {
-          await prepareStore();
-          final newChannel = eg.stream();
-          await channelStore.addStream(newChannel);
-          await channelStore.addSubscription(eg.subscription(newChannel));
-          fillWithMessages(readMessages);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: readMessages,
-            newStreamId: newChannel.streamId));
-          checkNotNotified();
-          checkMatchesMessages([]);
-        });
-
-        test('to new topic', () async {
-          await prepareStore();
-          fillWithMessages(readMessages);
+      void doTestMove(String moveDescription, {
+        ZulipStream? channelAfterMove,
+        String? topicAfterMove,
+        required Set<StreamMessage> messages,
+        required Set<StreamMessage> messagesToMove,
+        required Set<StreamMessage> expectedUnreadMessagesAfterMove,
+      }) async {
+        assert(messages.containsAll(messagesToMove));
+        assert(channelAfterMove != null || topicAfterMove != null);
+        channelAfterMove ??= origChannel;
+        topicAfterMove ??= origTopic;
+
+        test('$moveDescription from #${origChannel.name} > $origTopic, to #${channelAfterMove.name} > $newTopic', () async {
+          prepare();
+          await channelStore.addStreams(
+            [origChannel, newChannel, newUnsubscribedChannel]);
+          await channelStore.addSubscriptions(
+            [eg.subscription(origChannel), eg.subscription(newChannel)]);
+          fillWithMessages(messages);
 
           model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: readMessages,
-            newTopicStr: newTopic));
-          checkNotNotified();
-          checkMatchesMessages([]);
-        });
-
-        test('from topic with unreads', () async {
-          await prepareStore();
-          final unreadMessage = eg.streamMessage(
-            stream: origChannel, topic: origTopic);
-          fillWithMessages([...readMessages, unreadMessage]);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: readMessages,
-            newTopicStr: newTopic));
-          checkNotNotified();
-          checkMatchesMessages([unreadMessage]);
-        });
-
-        test('to topic with unreads', () async {
-          await prepareStore();
-          final unreadMessage = eg.streamMessage(
-            stream: origChannel, topic: newTopic);
-          fillWithMessages([...readMessages, unreadMessage]);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: readMessages,
-            newTopicStr: newTopic,
+            origMessages: messagesToMove.toList(),
+            newStreamId: channelAfterMove!.streamId,
+            newTopicStr: topicAfterMove,
           ));
-          checkNotNotified();
-          checkMatchesMessages([unreadMessage]);
-        });
-      });
-
-      group('move unread messages', () {
-        final unreadMessages = List<StreamMessage>.generate(10,
-          (_) => eg.streamMessage(stream: origChannel, topic: origTopic));
-
-        test('to another subscribed channel; same topic name', () async {
-          await prepareStore();
-          final newChannel = eg.stream();
-          await channelStore.addStream(newChannel);
-          await channelStore.addSubscription(eg.subscription(newChannel));
-          fillWithMessages(unreadMessages);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newStreamId: newChannel.streamId));
-          checkNotifiedOnce();
-          checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(
-                message.toJson()..['stream_id'] = newChannel.streamId),
-          ]);
-        });
-
-        test('to another subscribed channel; different topic name', () async {
-          await prepareStore();
-          final newChannel = eg.stream();
-          await channelStore.addStream(newChannel);
-          await channelStore.addSubscription(eg.subscription(newChannel));
-          fillWithMessages(unreadMessages);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newStreamId: newChannel.streamId,
-            newTopicStr: newTopic));
-          checkNotifiedOnce();
-          checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(
-                message.toJson()
-                  ..['stream_id'] = newChannel.streamId
-                  ..['subject'] = newTopic
-              ),
-          ]);
-        });
-
-        test('to unsubscribed channel', () async {
-          await prepareStore();
-          final newChannel = eg.stream();
-          await channelStore.addStream(newChannel);
-          assert(!channelStore.subscriptions.containsKey(newChannel.streamId));
-          fillWithMessages(unreadMessages);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newStreamId: newChannel.streamId));
-          checkNotifiedOnce();
-          checkMatchesMessages([]);
-        });
-
-        test('to new topic', () async {
-          await prepareStore();
-          fillWithMessages(unreadMessages);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newTopicStr: newTopic));
-          checkNotifiedOnce();
-          checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(message.toJson()..['subject'] = newTopic),
-          ]);
-        });
-
-        test('from topic containing other unreads', () async {
-          await prepareStore();
-          final unreadMessage = eg.streamMessage(
-            stream: origChannel, topic: origTopic);
-          fillWithMessages([...unreadMessages, unreadMessage]);
-
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newTopicStr: newTopic));
-          checkNotifiedOnce();
+          final movedUnreads =
+            expectedUnreadMessagesAfterMove.intersection(messagesToMove);
+          final otherUnreads =
+            expectedUnreadMessagesAfterMove.difference(messagesToMove);
           checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(message.toJson()..['subject'] = newTopic),
-            unreadMessage,
+            for (final message in movedUnreads)
+              StreamMessage.fromJson(message.toJson()
+                ..['stream_id'] = channelAfterMove.streamId
+                ..['subject'] = topicAfterMove),
+            ...otherUnreads,
           ]);
+          // The union of `movedUnreads` and `otherUnreads` might not contain
+          // some unreads found with this check, since unreads can be dropped
+          // when they are moved to an unsubscribed channel.
+          messagesToMove.any(
+            (message) => !message.flags.contains(MessageFlag.read)
+          ) ? checkNotifiedOnce()
+            : checkNotNotified();
         });
+      }
 
-        test('to topic containing other unreads', () async {
-          await prepareStore();
-          final unreadMessage = eg.streamMessage(
-            stream: origChannel, topic: newTopic);
-          fillWithMessages([...unreadMessages, unreadMessage]);
+      final unreadMessages = List<StreamMessage>.generate(10,
+        (_) => eg.streamMessage(stream: origChannel, topic: origTopic)).toSet();
+      final readMessages = List<StreamMessage>.generate(10,
+        (_) => eg.streamMessage(
+          stream: origChannel, topic: origTopic, flags: [MessageFlag.read])).toSet();
+      final messagesAtStart = unreadMessages.union(readMessages);
+      final messagesToMoveCases = [
+        ('move some unread messages', unreadMessages.take(5).toSet()),
+        ('move some read messages',   readMessages.take(5).toSet()),
+        ('move all unread messages',  unreadMessages),
+        ('move all read messages',    readMessages),
+        ('move all messages',         messagesAtStart),
+      ];
 
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newTopicStr: newTopic));
-          checkNotifiedOnce();
-          checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(message.toJson()..['subject'] = newTopic),
-            unreadMessage,
-          ]);
-        });
+      group('move to conversations with unreads', () {
+        final destinations = [
+          (newChannel, newTopic),
+          (newChannel, null),
+          (null,       newTopic),
+        ];
+        for (final (moveDescription, messagesToMove) in messagesToMoveCases) {
+          for (final (channel, topic) in destinations) {
+            final unreadMessagesAtDestination = List<StreamMessage>.generate(10,
+              (_) => eg.streamMessage(stream: channel, topic: topic)).toSet();
+            doTestMove(moveDescription,
+              channelAfterMove: channel,
+              topicAfterMove: topic,
+              messages: messagesAtStart.union(unreadMessagesAtDestination),
+              messagesToMove: messagesToMove,
+              expectedUnreadMessagesAfterMove:
+                unreadMessages.union(unreadMessagesAtDestination));
+          }
+        }
+      });
 
-        test('tolerates unsorted messages', () async {
-          await prepareStore();
-          final unreadMessages = List.generate(10,
-            (i) => eg.streamMessage(id: 1000-i, stream: origChannel, topic: origTopic));
-          fillWithMessages(unreadMessages);
+      group('move to conversations in unsubscribed channels', () {
+        final unsubscribedDestinations = [
+          (newUnsubscribedChannel, newTopic),
+          (newUnsubscribedChannel, null),
+        ];
+        for (final (moveDescription, messagesToMove) in messagesToMoveCases) {
+          for (final (channel, topic) in unsubscribedDestinations) {
+            doTestMove(moveDescription,
+              channelAfterMove: channel,
+              topicAfterMove: topic,
+              messages: messagesAtStart,
+              messagesToMove: messagesToMove,
+              expectedUnreadMessagesAfterMove:
+                unreadMessages.difference(messagesToMove));
+          }
+        }
+      });
 
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: unreadMessages,
-            newTopicStr: newTopic));
-          checkNotifiedOnce();
-          checkMatchesMessages([
-            for (final message in unreadMessages)
-              Message.fromJson(message.toJson()..['subject'] = newTopic)
-          ]);
-        });
+      test('tolerates unsorted messages', () async {
+        prepare();
+        await channelStore.addStream(origChannel);
+        await channelStore.addSubscription(eg.subscription(origChannel));
+        final unreadMessages = List.generate(10,
+          (i) => eg.streamMessage(id: 1000-i, stream: origChannel, topic: origTopic));
+        fillWithMessages(unreadMessages);
 
-        test('tolerates unreads unknown to the model', () async {
-          await prepareStore();
-          final unknownUnreadMessage = eg.streamMessage(
-            stream: eg.stream(), topic: origTopic);
-          fillWithMessages(unreadMessages);
+        model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
+          origMessages: unreadMessages,
+          newTopicStr: newTopic));
+        checkNotifiedOnce();
+        checkMatchesMessages([
+          for (final message in unreadMessages)
+            Message.fromJson(message.toJson()..['subject'] = newTopic)
+        ]);
+      });
 
-          model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
-            origMessages: [unknownUnreadMessage],
-            newTopicStr: newTopic));
-          checkNotNotified();
-          checkMatchesMessages(unreadMessages);
-        });
+      test('tolerates unreads unknown to the model', () async {
+        prepare();
+        await channelStore.addStream(origChannel);
+        await channelStore.addSubscription(eg.subscription(origChannel));
+        fillWithMessages(unreadMessages);
+
+        final unknownChannel = eg.stream();
+        assert(!channelStore.streams.containsKey(unknownChannel.streamId));
+        final unknownUnreadMessage = eg.streamMessage(
+          stream: unknownChannel, topic: origTopic);
+
+        model.handleUpdateMessageEvent(eg.updateMessageEventMoveFrom(
+          origMessages: [unknownUnreadMessage],
+          newTopicStr: newTopic));
+        checkNotNotified();
+        checkMatchesMessages(unreadMessages);
       });
     });
   });