supa test

Author: bnjbvr

crates/matrix-sdk-ui/tests/integration/main.rs

@@ -75,13 +75,17 @@ async fn mock_context(
             "event": event.event,
             "events_after": events_after.into_iter().map(|ev| ev.event).collect_vec(),
             "state": state,
-            "prev_batch_token": prev_batch_token,
-            "next_batch_token": next_batch_token
+            "start": prev_batch_token,
+            "end": next_batch_token
         })))
         .mount(&server)
         .await;
 }
 
+/// Mocks the /messages endpoint.
+///
+/// Note: pass `chunk` in the correct order: topological for forward pagination,
+/// reverse topological for backwards pagination.
 async fn mock_messages(
     server: &MockServer,
     start: String,

crates/matrix-sdk-ui/tests/integration/timeline/focus_event.rs

@@ -16,7 +16,6 @@
 
 use std::time::Duration;
 
-use assert_matches::assert_matches;
 use assert_matches2::assert_let;
 use eyeball_im::VectorDiff;
 use futures_util::StreamExt;
@@ -25,33 +24,29 @@ use matrix_sdk::{
     test_utils::{events::EventFactory, logged_in_client_with_server},
 };
 use matrix_sdk_test::{
-    async_test, sync_timeline_event, JoinedRoomBuilder, RoomAccountDataTestEvent, StateTestEvent,
-    SyncResponseBuilder, ALICE, BOB,
+    async_test, sync_timeline_event, JoinedRoomBuilder, SyncResponseBuilder, ALICE, BOB,
 };
-use matrix_sdk_ui::{
-    timeline::{RoomExt, TimelineFocus, TimelineItemContent, VirtualTimelineItem},
-    Timeline,
-};
-use ruma::{event_id, room_id, user_id};
+use matrix_sdk_ui::{timeline::TimelineFocus, Timeline};
+use ruma::{event_id, room_id};
 use stream_assert::assert_pending;
 
-use crate::{mock_context, mock_sync};
+use crate::{mock_context, mock_messages, mock_sync};
 
 #[async_test]
 async fn test_new_focused() {
     let room_id = room_id!("!a98sd12bjh:example.org");
     let (client, server) = logged_in_client_with_server().await;
     let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
 
-    let mut ev_builder = SyncResponseBuilder::new();
-    ev_builder.add_joined_room(JoinedRoomBuilder::new(room_id));
+    let mut sync_response_builder = SyncResponseBuilder::new();
+    sync_response_builder.add_joined_room(JoinedRoomBuilder::new(room_id));
 
     // Mark the room as joined.
-    mock_sync(&server, ev_builder.build_json_sync_response(), None).await;
+    mock_sync(&server, sync_response_builder.build_json_sync_response(), None).await;
     let _response = client.sync_once(sync_settings.clone()).await.unwrap();
     server.reset().await;
 
-    let factory = EventFactory::new().room(room_id);
+    let f = EventFactory::new().room(room_id);
     let target_event = event_id!("$1");
 
     mock_context(
@@ -60,13 +55,13 @@ async fn test_new_focused() {
         target_event,
         Some("prev1".to_owned()),
         vec![
-            factory.text_msg("i tried so hard").sender(*ALICE).into_timeline(),
-            factory.text_msg("and got so far").sender(*ALICE).into_timeline(),
+            f.text_msg("i tried so hard").sender(*ALICE).into_timeline(),
+            f.text_msg("and got so far").sender(*ALICE).into_timeline(),
         ],
-        factory.text_msg("in the end").sender(*BOB).into_timeline(),
+        f.text_msg("in the end").event_id(target_event).sender(*BOB).into_timeline(),
         vec![
-            factory.text_msg("it doesn't even").sender(*ALICE).into_timeline(),
-            factory.text_msg("matter").sender(*ALICE).into_timeline(),
+            f.text_msg("it doesn't even").sender(*ALICE).into_timeline(),
+            f.text_msg("matter").sender(*ALICE).into_timeline(),
         ],
         Some("next1".to_owned()),
         vec![],
@@ -105,4 +100,168 @@ async fn test_new_focused() {
     assert_eq!(items[5].as_event().unwrap().content().as_message().unwrap().body(), "matter");
 
     assert_pending!(timeline_stream);
+
+    // Now trigger a backward pagination.
+    mock_messages(
+        &server,
+        "prev1".to_owned(),
+        None,
+        vec![
+            // reversed manually here
+            f.text_msg("And even though I tried, it all fell apart").sender(*BOB).into_timeline(),
+            f.text_msg("I kept everything inside").sender(*BOB).into_timeline(),
+        ],
+        vec![],
+    )
+    .await;
+
+    let hit_start = timeline.focused_paginate_backwards(20).await.unwrap();
+    assert!(hit_start);
+
+    server.reset().await;
+
+    assert_let!(Some(VectorDiff::PushFront { value: message }) = timeline_stream.next().await);
+    assert_eq!(
+        message.as_event().unwrap().content().as_message().unwrap().body(),
+        "And even though I tried, it all fell apart"
+    );
+
+    assert_let!(Some(VectorDiff::PushFront { value: message }) = timeline_stream.next().await);
+    assert_eq!(
+        message.as_event().unwrap().content().as_message().unwrap().body(),
+        "I kept everything inside"
+    );
+
+    // Day divider post processing.
+    assert_let!(Some(VectorDiff::PushFront { value: item }) = timeline_stream.next().await);
+    assert!(item.is_day_divider());
+    assert_let!(Some(VectorDiff::Remove { index }) = timeline_stream.next().await);
+    assert_eq!(index, 3);
+
+    // Now trigger a forward pagination.
+    mock_messages(
+        &server,
+        "next1".to_owned(),
+        Some("next2".to_owned()),
+        vec![
+            f.text_msg("I had to fall, to lose it all").sender(*BOB).into_timeline(),
+            f.text_msg("But in the end, it doesn't event matter").sender(*BOB).into_timeline(),
+        ],
+        vec![],
+    )
+    .await;
+
+    let hit_start = timeline.focused_paginate_forwards(20).await.unwrap();
+    assert!(!hit_start); // because we gave it another next2 token.
+
+    server.reset().await;
+
+    assert_let!(Some(VectorDiff::PushBack { value: message }) = timeline_stream.next().await);
+    assert_eq!(
+        message.as_event().unwrap().content().as_message().unwrap().body(),
+        "I had to fall, to lose it all"
+    );
+
+    assert_let!(Some(VectorDiff::PushBack { value: message }) = timeline_stream.next().await);
+    assert_eq!(
+        message.as_event().unwrap().content().as_message().unwrap().body(),
+        "But in the end, it doesn't event matter"
+    );
+
+    assert_pending!(timeline_stream);
+}
+
+#[async_test]
+async fn test_focused_timeline_reacts() {
+    let room_id = room_id!("!a98sd12bjh:example.org");
+    let (client, server) = logged_in_client_with_server().await;
+    let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
+
+    let mut sync_response_builder = SyncResponseBuilder::new();
+    sync_response_builder.add_joined_room(JoinedRoomBuilder::new(room_id));
+
+    // Mark the room as joined.
+    mock_sync(&server, sync_response_builder.build_json_sync_response(), None).await;
+    let _response = client.sync_once(sync_settings.clone()).await.unwrap();
+    server.reset().await;
+
+    // Start a focused timeline.
+    let f = EventFactory::new().room(room_id);
+    let target_event = event_id!("$1");
+
+    mock_context(
+        &server,
+        room_id,
+        target_event,
+        None,
+        vec![],
+        f.text_msg("yolo").event_id(target_event).sender(*BOB).into_timeline(),
+        vec![],
+        None,
+        vec![],
+    )
+    .await;
+
+    let room = client.get_room(room_id).unwrap();
+    let timeline = Timeline::builder(&room)
+        .with_focus(TimelineFocus::Event {
+            target: target_event.to_owned(),
+            num_context_events: 20,
+        })
+        .build()
+        .await
+        .unwrap();
+
+    server.reset().await;
+
+    let (items, mut timeline_stream) = timeline.subscribe().await;
+
+    assert_eq!(items.len(), 1 + 1); // event items + a day divider
+    assert!(items[0].is_day_divider());
+
+    let event_item = items[1].as_event().unwrap();
+    assert_eq!(event_item.content().as_message().unwrap().body(), "yolo");
+    assert_eq!(event_item.reactions().len(), 0);
+
+    assert_pending!(timeline_stream);
+
+    // Now simulate a sync that returns a new message-like event, and a reaction
+    // to the $1 event.
+    sync_response_builder.add_joined_room(JoinedRoomBuilder::new(room_id).add_timeline_bulk([
+        // This event must be ignored.
+        f.text_msg("this is a sync event").sender(*ALICE).into_raw_sync(),
+        // This event must not be ignored.
+        sync_timeline_event!({
+            "content": {
+                "m.relates_to": {
+                    "event_id": "$1",
+                    "key": "👍",
+                    "rel_type": "m.annotation"
+                }
+            },
+            "event_id": "$15275047031IXQRi:localhost",
+            "origin_server_ts": 159027581000000_u64,
+            "sender": *BOB,
+            "type": "m.reaction",
+            "unsigned": {
+                "age": 85
+            }
+        }),
+    ]));
+
+    // Sync the room.
+    mock_sync(&server, sync_response_builder.build_json_sync_response(), None).await;
+    let _response = client.sync_once(sync_settings.clone()).await.unwrap();
+    server.reset().await;
+
+    assert_let!(Some(VectorDiff::Set { index: 1, value: item }) = timeline_stream.next().await);
+
+    let event_item = item.as_event().unwrap();
+    // Text hasn't changed.
+    assert_eq!(event_item.content().as_message().unwrap().body(), "yolo");
+    // But now there's one reaction to the event.
+    assert_eq!(event_item.reactions().len(), 1);
+
+    // And nothing more.
+    assert_pending!(timeline_stream);
 }