tests: add integration tests for the new timeline focus mode

bnjbvr · bnjbvr · commit a6c42404a63d · 2024-04-23T19:02:45.000+02:00
diff --git a/crates/matrix-sdk-ui/tests/integration/main.rs b/crates/matrix-sdk-ui/tests/integration/main.rs
@@ -12,8 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use itertools::Itertools as _;
+use matrix_sdk::deserialized_responses::TimelineEvent;
 use matrix_sdk_test::test_json;
+use ruma::{events::AnyStateEvent, serde::Raw, EventId, RoomId};
 use serde::Serialize;
+use serde_json::json;
 use wiremock::{
     matchers::{header, method, path, path_regex, query_param, query_param_is_missing},
     Mock, MockServer, ResponseTemplate,
@@ -32,22 +36,79 @@ matrix_sdk_test::init_tracing_for_tests!();
 /// an optional `since` param that returns a 200 status code with the given
 /// response body.
 async fn mock_sync(server: &MockServer, response_body: impl Serialize, since: Option<String>) {
-    let mut builder = Mock::given(method("GET"))
+    let mut mock_builder = Mock::given(method("GET"))
         .and(path("/_matrix/client/r0/sync"))
         .and(header("authorization", "Bearer 1234"));
 
     if let Some(since) = since {
-        builder = builder.and(query_param("since", since));
+        mock_builder = mock_builder.and(query_param("since", since));
     } else {
-        builder = builder.and(query_param_is_missing("since"));
+        mock_builder = mock_builder.and(query_param_is_missing("since"));
     }
 
-    builder
+    mock_builder
         .respond_with(ResponseTemplate::new(200).set_body_json(response_body))
         .mount(server)
         .await;
 }
 
+/// Mocks the /context endpoint
+///
+/// Note: pass `events_before` in the normal order, I'll revert the order for
+/// you.
+#[allow(clippy::too_many_arguments)] // clippy you've got such a fixed mindset
+async fn mock_context(
+    server: &MockServer,
+    room_id: &RoomId,
+    event_id: &EventId,
+    prev_batch_token: Option<String>,
+    events_before: Vec<TimelineEvent>,
+    event: TimelineEvent,
+    events_after: Vec<TimelineEvent>,
+    next_batch_token: Option<String>,
+    state: Vec<Raw<AnyStateEvent>>,
+) {
+    Mock::given(method("GET"))
+        .and(path(format!("/_matrix/client/r0/rooms/{room_id}/context/{event_id}")))
+        .and(header("authorization", "Bearer 1234"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "events_before": events_before.into_iter().rev().map(|ev| ev.event).collect_vec(),
+            "event": event.event,
+            "events_after": events_after.into_iter().map(|ev| ev.event).collect_vec(),
+            "state": state,
+            "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,
+    end: Option<String>,
+    chunk: Vec<TimelineEvent>,
+    state: Vec<Raw<AnyStateEvent>>,
+) {
+    Mock::given(method("GET"))
+        .and(path_regex(r"^/_matrix/client/r0/rooms/.*/messages$"))
+        .and(header("authorization", "Bearer 1234"))
+        .and(query_param("from", start.clone()))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "start": start,
+            "end": end,
+            "chunk": chunk.into_iter().map(|ev| ev.event).collect_vec(),
+            "state": state,
+        })))
+        .expect(1)
+        .mount(server)
+        .await;
+}
+
 /// Mount a Mock on the given server to handle the `GET
 /// /rooms/.../state/m.room.encryption` endpoint with an option whether it
 /// should return an encryption event or not.
diff --git a/crates/matrix-sdk-ui/tests/integration/timeline/focus_event.rs b/crates/matrix-sdk-ui/tests/integration/timeline/focus_event.rs
@@ -0,0 +1,267 @@
+// Copyright 2024 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Tests specific to a timeline focused on an event.
+
+use std::time::Duration;
+
+use assert_matches2::assert_let;
+use eyeball_im::VectorDiff;
+use futures_util::StreamExt;
+use matrix_sdk::{
+    config::SyncSettings,
+    test_utils::{events::EventFactory, logged_in_client_with_server},
+};
+use matrix_sdk_test::{
+    async_test, sync_timeline_event, JoinedRoomBuilder, SyncResponseBuilder, ALICE, BOB,
+};
+use matrix_sdk_ui::{timeline::TimelineFocus, Timeline};
+use ruma::{event_id, room_id};
+use stream_assert::assert_pending;
+
+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 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;
+
+    let f = EventFactory::new().room(room_id);
+    let target_event = event_id!("$1");
+
+    mock_context(
+        &server,
+        room_id,
+        target_event,
+        Some("prev1".to_owned()),
+        vec![
+            f.text_msg("i tried so hard").sender(*ALICE).into_timeline(),
+            f.text_msg("and got so far").sender(*ALICE).into_timeline(),
+        ],
+        f.text_msg("in the end").event_id(target_event).sender(*BOB).into_timeline(),
+        vec![
+            f.text_msg("it doesn't even").sender(*ALICE).into_timeline(),
+            f.text_msg("matter").sender(*ALICE).into_timeline(),
+        ],
+        Some("next1".to_owned()),
+        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(), 5 + 1); // event items + a day divider
+    assert!(items[0].is_day_divider());
+    assert_eq!(
+        items[1].as_event().unwrap().content().as_message().unwrap().body(),
+        "i tried so hard"
+    );
+    assert_eq!(
+        items[2].as_event().unwrap().content().as_message().unwrap().body(),
+        "and got so far"
+    );
+    assert_eq!(items[3].as_event().unwrap().content().as_message().unwrap().body(), "in the end");
+    assert_eq!(
+        items[4].as_event().unwrap().content().as_message().unwrap().body(),
+        "it doesn't even"
+    );
+    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);
+}
diff --git a/crates/matrix-sdk-ui/tests/integration/timeline/mod.rs b/crates/matrix-sdk-ui/tests/integration/timeline/mod.rs
@@ -30,6 +30,7 @@ use crate::mock_sync;
 
 mod echo;
 mod edit;
+mod focus_event;
 mod pagination;
 mod profiles;
 mod queue;
