matrix-rust-sdk

public

Star0

Fork 0

Watch0

26 commits 4 branches 0 tags 0 releases16.6 MiB

Commit `b04108dd8339`

tarball

atagen <boss@atagen.co>2026-10-25 10:29 UTC

2 files changed+18-333

tests: align limited sync tests with retained history

The fork keeps retained events and records a HistoryGap on a limited sync instead of shrinking to the last chunk, so tests that waited for the shrink Clear or relied on its pagination reset no longer described real behaviour. The deduplication and relations tests now check the continuous window and fill the history gap, and the two reset-while-paginating tests are gone since no limited sync resets the room any more.

Modified file: crates/matrix-sdk-ui/tests/integration/timeline/pagination.rs+1 additions−158 deletions@@ -30,7 +30,7 @@ use matrix_sdk::{
     event_cache::PaginationStatus,
     test_utils::mocks::{MatrixMockServer, RoomMessagesResponseTemplate},
 };
-use matrix_sdk_test::{ALICE, BOB, JoinedRoomBuilder, async_test, event_factory::EventFactory};
+use matrix_sdk_test::{ALICE, JoinedRoomBuilder, async_test, event_factory::EventFactory};
 use matrix_sdk_ui::timeline::{AnyOtherStateEventContentChange, RoomExt, TimelineItemContent};
 use ruma::{
     EventId, event_id,
@@ -538,163 +538,6 @@ async fn test_dedup_pagination() {
     server.server().verify().await;
 }
 
-#[async_test]
-async fn test_timeline_reset_while_paginating() {
-    let room_id = room_id!("!a98sd12bjh:example.org");
-    let server = MatrixMockServer::new().await;
-    let client = server.client_builder().build().await;
-
-    let f = EventFactory::new();
-    let room = server.sync_joined_room(&client, room_id).await;
-    let timeline = Arc::new(room.timeline().await.unwrap());
-
-    let alice_event = f.text_msg("live event!").sender(&ALICE).room(room_id).into_raw_timeline();
-    server
-        .mock_sync()
-        .ok(|b| {
-            b.add_joined_room(
-                JoinedRoomBuilder::new(room_id)
-                    .add_timeline_event(alice_event.clone().cast())
-                    .set_timeline_prev_batch("pagination_1".to_owned())
-                    .set_timeline_limited(),
-            );
-        })
-        .mock_once()
-        .mount()
-        .await;
-    client.sync_once(Default::default()).await.unwrap();
-
-    // Next sync response will respond with pagination_2 token and limited
-    // response, resetting the timeline.
-    let sync_mock_guard = server
-        .mock_sync()
-        .ok(|b| {
-            b.add_joined_room(
-                JoinedRoomBuilder::new(room_id)
-                    .add_timeline_event(f.text_msg("new live event.").sender(&BOB))
-                    .set_timeline_prev_batch("pagination_2".to_owned())
-                    .set_timeline_limited(),
-            );
-        })
-        .mock_once()
-        .mount_as_scoped()
-        .await;
-
-    // The pagination with the first token will be hit twice:
-    // - first, before the sync response comes, then the gap is stored in the cache.
-    // - second, after all other gaps have been resolved, we get back to resolving
-    //   this one.
-    server
-        .mock_room_messages()
-        .match_from("pagination_1")
-        .respond_with(
-            ResponseTemplate::new(200)
-                .set_body_json(json!({
-                    "chunk": [],
-                    "start": "pagination_1",
-                    "end": "pagination_3",
-                }))
-                // Make sure the concurrent sync request returns first
-                .set_delay(Duration::from_millis(200)),
-        )
-        .expect(2)
-        .named("pagination_1")
-        .mount()
-        .await;
-
-    // The pagination with the second token must return Alice's event, to be
-    // consistent with the room's timeline (Alice's event was observed before
-    // Bob's event).
-    server
-        .mock_room_messages()
-        .match_from("pagination_2")
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-            "chunk": [alice_event],
-            "start": "pagination_2",
-        })))
-        .expect(1)
-        .named("pagination_2")
-        .mount()
-        .await;
-
-    // pagination with third token
-    server
-        .mock_room_messages()
-        .match_from("pagination_3")
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-            "chunk": [],
-            "start": "pagination_3",
-        })))
-        .expect(1)
-        .named("pagination_3")
-        .mount()
-        .await;
-
-    let (_, mut back_pagination_status) = timeline.live_back_pagination_status().await.unwrap();
-
-    let paginate = async {
-        let mut hit_start;
-        loop {
-            hit_start = timeline.paginate_backwards(10).await.unwrap();
-            if hit_start {
-                break;
-            }
-        }
-        hit_start
-    };
-
-    let observe_paginating = async {
-        let mut seen_paginating = false;
-        let mut seen_idle_no_start = false;
-
-        // Observe paginating updates: we want to make sure we see at least once
-        // Paginating, and that it settles with Idle.
-        while let Ok(update) =
-            timeout(Duration::from_millis(500), back_pagination_status.next()).await
-        {
-            match update {
-                Some(state) => {
-                    if state == PaginationStatus::Paginating {
-                        seen_paginating = true;
-                    }
-                    if matches!(state, PaginationStatus::Idle { hit_timeline_start: false }) {
-                        seen_idle_no_start = true;
-                    }
-                }
-                None => break,
-            }
-        }
-
-        assert!(seen_paginating);
-        assert!(seen_idle_no_start);
-
-        let (status, _) = timeline.live_back_pagination_status().await.unwrap();
-
-        // Timeline start reached because second pagination response contains no end
-        // field.
-        assert_eq!(status, PaginationStatus::Idle { hit_timeline_start: true });
-    };
-
-    let sync = async {
-        client.sync_once(Default::default()).await.unwrap();
-    };
-
-    let (hit_start, _, _) =
-        timeout(Duration::from_secs(5), join3(paginate, observe_paginating, sync)).await.unwrap();
-
-    // Timeline start reached because second pagination response contains no end
-    // field.
-    assert!(hit_start);
-
-    // No events in back-pagination responses, start of timeline + date divider +
-    // all events from the previous syncs are present.
-    assert_eq!(timeline.items().await.len(), 4);
-
-    // Make sure both pagination mocks were called.
-    drop(sync_mock_guard);
-    server.server().verify().await;
-}
-
 pub static ROOM_MESSAGES_BATCH_1: LazyLock<JsonValue> = LazyLock::new(|| {
     json!({
         "chunk": [

Modified file: crates/matrix-sdk/tests/integration/event_cache/mod.rs+17 additions−175 deletions@@ -9,8 +9,8 @@ use matrix_sdk::{
     assert_let_timeout, assert_next_matches_with_timeout,
     deserialized_responses::TimelineEvent,
     event_cache::{
-        BackPaginationOutcome, EventCacheError, PaginationStatus, RoomEventCacheUpdate,
-        TimelineVectorDiffs,
+        BackPaginationOutcome, EventCacheError, HistoryGapFillOutcome, PaginationStatus,
+        RoomEventCacheUpdate, TimelineVectorDiffs,
     },
     linked_chunk::{ChunkIdentifier, LinkedChunkId, Position, Update},
     store::StoreConfig,
@@ -567,134 +567,6 @@ async fn test_backpaginate_many_times_with_one_iteration() {
 }
 
 #[async_test]
-async fn test_reset_while_backpaginating() {
-    let server = MatrixMockServer::new().await;
-    let client = server.client_builder().build().await;
-
-    let event_cache = client.event_cache();
-
-    // Immediately subscribe the event cache to sync updates.
-    event_cache.subscribe().unwrap();
-
-    // If I sync and get informed I've joined The Room, and get a previous batch
-    // token,
-    let room_id = room_id!("!omelette:fromage.fr");
-
-    let f = EventFactory::new().room(room_id).sender(user_id!("@a:b.c"));
-
-    server
-        .sync_room(
-            &client,
-            JoinedRoomBuilder::new(room_id)
-                // Note to self: a timeline must have at least single event to be properly
-                // serialized.
-                .add_timeline_event(f.text_msg("heyo").into_raw_sync())
-                .set_timeline_prev_batch("first_backpagination".to_owned())
-                .set_timeline_limited(),
-        )
-        .await;
-
-    let (room_event_cache, _drop_handles) =
-        client.get_room(room_id).unwrap().event_cache().await.unwrap();
-
-    let (events, mut room_stream) = room_event_cache.subscribe().await.unwrap();
-
-    wait_for_initial_events(events, &mut room_stream).await;
-
-    // We're going to cause a small race:
-    // - a pagination request to sync will be sent,
-    // - a backpagination will be sent concurrently.
-    //
-    // So events have to happen in this order:
-    // - the backpagination request is sent, with a prev-batch A
-    // - the sync endpoint returns *after* the backpagination started, before the
-    // backpagination ends
-    // - the backpagination ends, with a prev-batch token that's now stale.
-    //
-    // The backpagination should result in an unknown-token-error.
-
-    // Mock the first back-pagination request, with a delay.
-    server
-        .mock_room_messages()
-        .match_from("first_backpagination")
-        .ok(RoomMessagesResponseTemplate::default()
-            .events(vec![f.text_msg("lalala").into_raw_timeline()])
-            .with_delay(Duration::from_millis(500)))
-        .mock_once()
-        .mount()
-        .await;
-
-    // Mock the second back-pagination request, that will be hit after the reset
-    // caused by the sync.
-    server
-        .mock_room_messages()
-        .match_from("second_backpagination")
-        .ok(RoomMessagesResponseTemplate::default()
-            .end_token("third_backpagination")
-            .events(vec![f.text_msg("finally!").into_raw_timeline()]))
-        .mock_once()
-        .mount()
-        .await;
-
-    // Run the pagination!
-    let backpagination = spawn({
-        let pagination = room_event_cache.pagination();
-        async move { pagination.run_backwards_once(20).await }
-    });
-
-    // Receive the sync response (which clears the timeline).
-    server
-        .sync_room(
-            &client,
-            JoinedRoomBuilder::new(room_id)
-                // Note to self: a timeline must have at least single event to be properly
-                // serialized.
-                .add_timeline_event(f.text_msg("heyo").into_raw_sync())
-                .set_timeline_prev_batch("second_backpagination".to_owned())
-                .set_timeline_limited(),
-        )
-        .await;
-
-    let outcome = backpagination.await.expect("join failed").unwrap();
-
-    // Backpagination will automatically restart, so eventually we get the events.
-    let BackPaginationOutcome { events, .. } = outcome;
-    assert!(!events.is_empty());
-
-    // Assert the updates as diffs.
-    {
-        // The room shrinks the linked chunk to the last event chunk, so it clears and
-        // re-adds the latest event.
-        assert_let_timeout!(
-            Ok(RoomEventCacheUpdate::UpdateTimelineEvents(TimelineVectorDiffs { diffs, .. })) =
-                room_stream.recv()
-        );
-        assert_eq!(diffs.len(), 2);
-        assert_matches!(&diffs[0], VectorDiff::Clear);
-        assert_matches!(&diffs[1], VectorDiff::Append { values } => {
-            assert_eq!(values.len(), 1);
-            assert_event_matches_msg(&values[0], "heyo");
-        });
-    }
-
-    {
-        // Then we receive the event from the restarted back-pagination with
-        // `second_backpagination`.
-        assert_let_timeout!(
-            Ok(RoomEventCacheUpdate::UpdateTimelineEvents(TimelineVectorDiffs { diffs, .. })) =
-                room_stream.recv()
-        );
-        assert_eq!(diffs.len(), 1);
-        assert_matches!(&diffs[0], VectorDiff::Insert { index, value: event } => {
-            assert_eq!(*index, 0);
-            assert_event_matches_msg(event, "finally!");
-        });
-    }
-
-    assert!(room_stream.is_empty());
-}
-
-#[async_test]
 async fn test_backpaginating_without_token() {
     let server = MatrixMockServer::new().await;
     let client = server.client_builder().build().await;
@@ -1212,6 +1084,7 @@ async fn test_no_gap_stored_after_deduplicated_backpagination() {
     }
 
     drop(events);
+    let events_before_expansion = f.text_msg("sup").event_id(event_id!("$3")).into_event();
 
     // Now, simulate that we expanded the timeline window with sliding sync, by
     // returning more items.
@@ -1229,45 +1102,23 @@ async fn test_no_gap_stored_after_deduplicated_backpagination() {
         )
         .await;
 
+    // The retained `$3` is part of the expanded window, so the sync is continuous
+    // with it: prev-batch2 is dropped, and `$3` moves behind `$1` and `$2`.
     assert_let_timeout!(
         Ok(RoomEventCacheUpdate::UpdateTimelineEvents(TimelineVectorDiffs { diffs, .. })) =
             stream.recv()
     );
-    assert_eq!(diffs.len(), 2);
-
-    assert_matches!(&diffs[0], VectorDiff::Clear);
-
-    // Then the latest event chunk is reloaded.
-    // `$ev1`, `$ev2` and `$ev3` are added.
-    assert_matches!(&diffs[1], VectorDiff::Append { values: events } => {
-        assert_eq!(events.len(), 3);
-        assert_eq!(events[0].event_id().unwrap().as_str(), "$1");
-        assert_eq!(events[1].event_id().unwrap().as_str(), "$2");
-        assert_eq!(events[2].event_id().unwrap().as_str(), "$3");
-    });
+    let mut visible = imbl::vector![events_before_expansion];
+    for diff in diffs {
+        diff.apply(&mut visible);
+    }
+    let ids: Vec<_> = visible.iter().filter_map(|event| event.event_id()).collect();
+    assert_eq!(ids, [event_id!("$1"), event_id!("$2"), event_id!("$3")]);
 
     assert!(stream.is_empty());
 
-    // For prev-batch2, the back-pagination returns nothing.
-    server
-        .mock_room_messages()
-        .match_from("prev-batch2")
-        .ok(RoomMessagesResponseTemplate::default())
-        .mock_once()
-        .mount()
-        .await;
-
-    // Run pagination once: it will consume prev-batch2 first, which is the most
-    // recent token, which returns an empty batch, thus indicating the start of the
-    // room; but we still have a chunk in storage, so it appears like it's not the
-    // start *yet*.
     let pagination = room_event_cache.pagination();
 
-    let outcome = pagination.run_backwards_once(20).await.unwrap();
-    assert!(outcome.reached_start.not());
-    assert!(outcome.events.is_empty());
-    assert!(stream.is_empty());
-
     // For prev-batch, the back-pagination returns two events we already know, and a
     // previous batch token.
     server
@@ -2652,8 +2503,8 @@ async fn test_relations_ordering() {
         .edit(target_event_id, RoomMessageEventContentWithoutRelation::text_plain("hello world"))
         .event_id(edit4);
 
-    // We receive two edit events via sync, as well as a gap; this will shrink the
-    // linked chunk.
+    // We receive two edit events via sync, as well as a gap, which keeps the
+    // retained target and records a history gap after it.
     server
         .sync_room(
             &client,
@@ -2671,8 +2522,7 @@ async fn test_relations_ordering() {
             Ok(RoomEventCacheUpdate::UpdateTimelineEvents(TimelineVectorDiffs { diffs, .. })) =
                 listener.recv()
         );
-        // We've received the shrink.
-        if diffs.iter().any(|diff| matches!(diff, VectorDiff::Clear)) {
+        if diffs.iter().any(|diff| matches!(diff, VectorDiff::Append { .. })) {
             break;
         }
     }
@@ -2696,17 +2546,9 @@ async fn test_relations_ordering() {
         .mount()
         .await;
 
-    // Run the pagination.
-    let outcome = room_event_cache.pagination().run_backwards_once(1).await.unwrap();
-    assert!(outcome.reached_start.not());
-    assert_eq!(outcome.events.len(), 1);
-
-    {
-        // Sanity check: we load the first chunk with the first event, from disk, and
-        // reach the start of the timeline.
-        let outcome = room_event_cache.pagination().run_backwards_once(1).await.unwrap();
-        assert!(outcome.reached_start);
-    }
+    let gap_id = room_event_cache.history_gaps().await.unwrap()[0].id.clone();
+    let outcome = room_event_cache.fill_history_gap_once(gap_id).await.unwrap();
+    assert_matches!(outcome, HistoryGapFillOutcome::Updated { events: 1, .. });
 
     // Relations are returned accordingly.
     let (_, relations) =

matrix-rust-sdk

Commit b04108dd8339

Commit `b04108dd8339`