msglist: Make initial fetch from any anchor, in model

This is NFC as to the live app, because we continue to always set
the anchor to AnchorCode.newest there.

Author: gnprice

lib/model/message_list.dart

@@ -13,6 +13,8 @@ import 'content.dart';
 import 'narrow.dart';
 import 'store.dart';
 
+export '../api/route/messages.dart' show Anchor, AnchorCode, NumericAnchor;
+
 /// The number of messages to fetch in each request.
 const kMessageListFetchBatchSize = 100; // TODO tune
 
@@ -126,9 +128,6 @@ mixin _MessageSequence {
 
   /// Whether we know we have the newest messages for this narrow.
   ///
-  /// (Currently this is always true once [fetched] is true,
-  /// because we start from the newest.)
-  ///
   /// See also [haveOldest].
   bool get haveNewest => _haveNewest;
   bool _haveNewest = false;
@@ -418,14 +417,20 @@ bool _sameDay(DateTime date1, DateTime date2) {
 ///  * When the object will no longer be used, call [dispose] to free
 ///    resources on the [PerAccountStore].
 class MessageListView with ChangeNotifier, _MessageSequence {
-  factory MessageListView.init(
-      {required PerAccountStore store, required Narrow narrow}) {
-    return MessageListView._(store: store, narrow: narrow)
+  factory MessageListView.init({
+    required PerAccountStore store,
+    required Narrow narrow,
+    Anchor anchor = AnchorCode.newest, // TODO(#82): make required, for explicitness
+  }) {
+    return MessageListView._(store: store, narrow: narrow, anchor: anchor)
       .._register();
   }
 
-  MessageListView._({required this.store, required Narrow narrow})
-    : _narrow = narrow;
+  MessageListView._({
+    required this.store,
+    required Narrow narrow,
+    required Anchor anchor,
+  }) : _narrow = narrow, _anchor = anchor;
 
   final PerAccountStore store;
 
@@ -435,6 +440,17 @@ class MessageListView with ChangeNotifier, _MessageSequence {
   Narrow get narrow => _narrow;
   Narrow _narrow;
 
+  /// The anchor point this message list starts from in the message history.
+  ///
+  /// This is passed to the server in the get-messages request
+  /// sent by [fetchInitial].
+  /// That includes not only the original [fetchInitial] call made by
+  /// the message-list widget, but any additional [fetchInitial] calls
+  /// which might be made internally by this class in order to
+  /// fetch the messages from scratch, e.g. after certain events.
+  Anchor get anchor => _anchor;
+  final Anchor _anchor;
+
   void _register() {
     store.registerMessageList(this);
   }
@@ -520,16 +536,14 @@ class MessageListView with ChangeNotifier, _MessageSequence {
 
   /// Fetch messages, starting from scratch.
   Future<void> fetchInitial() async {
-    // TODO(#80): fetch from anchor firstUnread, instead of newest
-    // TODO(#82): fetch from a given message ID as anchor
     assert(!fetched && !haveOldest && !haveNewest && !busyFetchingMore);
     assert(messages.isEmpty && contents.isEmpty);
     _setStatus(FetchingStatus.fetchInitial, was: FetchingStatus.unstarted);
     // TODO schedule all this in another isolate
     final generation = this.generation;
     final result = await getMessages(store.connection,
       narrow: narrow.apiEncode(),
-      anchor: AnchorCode.newest,
+      anchor: anchor,
       numBefore: kMessageListFetchBatchSize,
       numAfter: kMessageListFetchBatchSize,
       allowEmptyTopicName: true,
@@ -541,12 +555,20 @@ class MessageListView with ChangeNotifier, _MessageSequence {
     store.reconcileMessages(result.messages);
     store.recentSenders.handleMessages(result.messages); // TODO(#824)
 
-    // We'll make the bottom slice start at the last visible message, if any.
+    // The bottom slice will start at the "anchor message".
+    // This is the first visible message at or past [anchor] if any,
+    // else the last visible message if any.  [reachedAnchor] helps track that.
+    bool reachedAnchor = false;
     for (final message in result.messages) {
       if (!_messageVisible(message)) continue;
-      middleMessage = messages.length;
+      if (!reachedAnchor) {
+        // Push the previous message into the top slice.
+        middleMessage = messages.length;
+        // We could interpret [anchor] for ourselves; but the server has already
+        // done that work, reducing it to an int, `result.anchor`.  So use that.
+        reachedAnchor = message.id >= result.anchor;
+      }
       _addMessage(message);
-      // Now [middleMessage] is the last message (the one just added).
     }
     _haveOldest = result.foundOldest;
     _haveNewest = result.foundNewest;

lib/widgets/message_list.dart

@@ -476,7 +476,11 @@ class _MessageListState extends State<MessageList> with PerAccountStoreAwareStat
   }
 
   void _initModel(PerAccountStore store) {
-    _model = MessageListView.init(store: store, narrow: widget.narrow);
+    // TODO(#82): get anchor as page/route argument, instead of using newest
+    // TODO(#80): default to anchor firstUnread, instead of newest
+    final anchor = AnchorCode.newest;
+    _model = MessageListView.init(store: store,
+      narrow: widget.narrow, anchor: anchor);
     model.addListener(_modelChanged);
     model.fetchInitial();
   }

test/model/message_list_test.dart

@@ -67,15 +67,18 @@ void main() {
   void checkNotifiedOnce() => checkNotified(count: 1);
 
   /// Initialize [model] and the rest of the test state.
-  Future<void> prepare({Narrow narrow = const CombinedFeedNarrow()}) async {
+  Future<void> prepare({
+    Narrow narrow = const CombinedFeedNarrow(),
+    Anchor anchor = AnchorCode.newest,
+  }) async {
     final stream = eg.stream(streamId: eg.defaultStreamMessageStreamId);
     subscription = eg.subscription(stream);
     store = eg.store();
     await store.addStream(stream);
     await store.addSubscription(subscription);
     connection = store.connection as FakeApiConnection;
     notifiedCount = 0;
-    model = MessageListView.init(store: store, narrow: narrow)
+    model = MessageListView.init(store: store, narrow: narrow, anchor: anchor)
       ..addListener(() {
         checkInvariants(model);
         notifiedCount++;
@@ -88,11 +91,18 @@ void main() {
   ///
   /// The test case must have already called [prepare] to initialize the state.
   Future<void> prepareMessages({
-    required bool foundOldest,
+    bool? foundOldest,
+    bool? foundNewest,
+    int? anchorMessageId,
     required List<Message> messages,
   }) async {
-    connection.prepare(json:
-      newestResult(foundOldest: foundOldest, messages: messages).toJson());
+    final result = eg.getMessagesResult(
+      anchor: model.anchor == AnchorCode.firstUnread
+        ? NumericAnchor(anchorMessageId!) : model.anchor,
+      foundOldest: foundOldest,
+      foundNewest: foundNewest,
+      messages: messages);
+    connection.prepare(json: result.toJson());
     await model.fetchInitial();
     checkNotifiedOnce();
   }
@@ -187,11 +197,7 @@ void main() {
     });
 
     test('early in history', () async {
-      // For now, this gets a response that isn't realistic for the
-      // request it sends, to simulate when we start sending requests
-      // that would make this response realistic.
-      // TODO(#82): send appropriate fetch request
-      await prepare();
+      await prepare(anchor: NumericAnchor(1000));
       connection.prepare(json: nearResult(
         anchor: 1000, foundOldest: true, foundNewest: false,
         messages: List.generate(111, (i) => eg.streamMessage(id: 990 + i)),
@@ -219,6 +225,26 @@ void main() {
         ..haveNewest.isTrue();
     });
 
+    group('sends proper anchor', () {
+      Future<void> checkFetchWithAnchor(Anchor anchor) async {
+        await prepare(anchor: anchor);
+        // This prepared response isn't entirely realistic, depending on the anchor.
+        // That's OK; these particular tests don't use the details of the response.
+        connection.prepare(json:
+          newestResult(foundOldest: true, messages: []).toJson());
+        await model.fetchInitial();
+        checkNotifiedOnce();
+        check(connection.lastRequest).isA<http.Request>()
+          .url.queryParameters['anchor']
+            .equals(anchor.toJson());
+      }
+
+      test('oldest',      () => checkFetchWithAnchor(AnchorCode.oldest));
+      test('firstUnread', () => checkFetchWithAnchor(AnchorCode.firstUnread));
+      test('newest',      () => checkFetchWithAnchor(AnchorCode.newest));
+      test('numeric',     () => checkFetchWithAnchor(NumericAnchor(12345)));
+    });
+
     // TODO(#824): move this test
     test('recent senders track all the messages', () async {
       const narrow = CombinedFeedNarrow();
@@ -1695,8 +1721,9 @@ void main() {
         ..middleMessage.equals(0);
     });
 
-    test('on fetchInitial not empty', () async {
-      await prepare(narrow: const CombinedFeedNarrow());
+    test('on fetchInitial, anchor past end', () async {
+      await prepare(narrow: const CombinedFeedNarrow(),
+        anchor: AnchorCode.newest);
       final stream1 = eg.stream();
       final stream2 = eg.stream();
       await store.addStreams([stream1, stream2]);
@@ -1719,6 +1746,34 @@ void main() {
             .equals(messages[messages.length - 2].id);
     });
 
+    test('on fetchInitial, anchor in middle', () async {
+      final s1 = eg.stream();
+      final s2 = eg.stream();
+      final messages = [
+        eg.streamMessage(id: 1, stream: s1), eg.streamMessage(id: 2, stream: s2),
+        eg.streamMessage(id: 3, stream: s1), eg.streamMessage(id: 4, stream: s2),
+        eg.streamMessage(id: 5, stream: s1), eg.streamMessage(id: 6, stream: s2),
+        eg.streamMessage(id: 7, stream: s1), eg.streamMessage(id: 8, stream: s2),
+      ];
+      final anchorId = 4;
+
+      await prepare(narrow: const CombinedFeedNarrow(),
+        anchor: NumericAnchor(anchorId));
+      await store.addStreams([s1, s2]);
+      await store.addSubscription(eg.subscription(s1));
+      await store.addSubscription(eg.subscription(s2, isMuted: true));
+      await prepareMessages(foundOldest: true, foundNewest: true,
+        messages: messages);
+      // The anchor message is the first visible message with ID at least anchorId…
+      check(model)
+        ..messages[model.middleMessage - 1].id.isLessThan(anchorId)
+        ..messages[model.middleMessage].id.isGreaterOrEqual(anchorId);
+      // … even though a non-visible message actually had anchorId itself.
+      check(messages[3].id)
+        ..equals(anchorId)
+        ..isLessThan(model.messages[model.middleMessage].id);
+    });
+
     /// Like [prepareMessages], but arrange for the given top and bottom slices.
     Future<void> prepareMessageSplit(List<Message> top, List<Message> bottom, {
       bool foundOldest = true,