look ma i'm writing tests and they found bugs

bnjbvr · bnjbvr · commit 2a6986875513 · 2024-04-23T18:18:12.000+02:00
diff --git a/crates/matrix-sdk-ui/src/timeline/event_handler.rs b/crates/matrix-sdk-ui/src/timeline/event_handler.rs
@@ -304,9 +304,31 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
                 }
                 trace!("Handling remote event");
 
-                // Only add new timeline items if we're in the live mode, i.e. not in the
-                // event-focused mode, *and* the event filter didn't filter this event out.
-                self.is_live_timeline && *should_add
+                // Retrieve the origin of the event.
+                let origin = match position {
+                    TimelineItemPosition::End { origin }
+                    | TimelineItemPosition::Start { origin } => *origin,
+
+                    TimelineItemPosition::Update(idx) => self
+                        .items
+                        .get(*idx)
+                        .and_then(|item| item.as_event())
+                        .and_then(|item| item.as_remote())
+                        .map_or(RemoteEventOrigin::Unknown, |item| item.origin),
+                };
+
+                match origin {
+                    RemoteEventOrigin::Sync | RemoteEventOrigin::Unknown => {
+                        // If the event comes the sync (or is unknown), consider adding it only if
+                        // the timeline is in live mode; we don't want to display arbitrary sync
+                        // events in an event-focused timeline.
+                        self.is_live_timeline && *should_add
+                    }
+                    RemoteEventOrigin::Pagination | RemoteEventOrigin::Cache => {
+                        // Otherwise, forward the previous decision to add it.
+                        *should_add
+                    }
+                }
             }
         };
 
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,74 @@ 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.
+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,
+            "prev_batch_token": prev_batch_token,
+            "next_batch_token": next_batch_token
+        })))
+        .mount(&server)
+        .await;
+}
+
+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,108 @@
+// 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_matches::assert_matches;
+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, RoomAccountDataTestEvent, StateTestEvent,
+    SyncResponseBuilder, ALICE, BOB,
+};
+use matrix_sdk_ui::{
+    timeline::{RoomExt, TimelineFocus, TimelineItemContent, VirtualTimelineItem},
+    Timeline,
+};
+use ruma::{event_id, room_id, user_id};
+use stream_assert::assert_pending;
+
+use crate::{mock_context, 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));
+
+    // Mark the room as joined.
+    mock_sync(&server, ev_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 target_event = event_id!("$1");
+
+    mock_context(
+        &server,
+        room_id,
+        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(),
+        ],
+        factory.text_msg("in the end").sender(*BOB).into_timeline(),
+        vec![
+            factory.text_msg("it doesn't even").sender(*ALICE).into_timeline(),
+            factory.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);
+}
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;
