test: get rid of TestTimeline::handle_live_message_event in favor of TestTimeline::handle_live_event

By using the `EventFactory` a bit more.

Part of #3716.

Author: bnjbvr

crates/matrix-sdk-ui/src/timeline/tests/basic.rs

@@ -16,16 +16,13 @@ use assert_matches::assert_matches;
 use assert_matches2::assert_let;
 use eyeball_im::VectorDiff;
 use matrix_sdk::test_utils::events::EventFactory;
-use matrix_sdk_base::deserialized_responses::SyncTimelineEvent;
 use matrix_sdk_test::{async_test, sync_timeline_event, ALICE, BOB, CAROL};
 use ruma::{
-    assign,
     events::{
         receipt::{Receipt, ReceiptThread, ReceiptType},
-        relation::{InReplyTo, Thread},
         room::{
             member::{MembershipState, RedactedRoomMemberEventContent, RoomMemberEventContent},
-            message::{MessageType, Relation, RoomMessageEventContent},
+            message::{MessageType, RoomMessageEventContent},
             name::RoomNameEventContent,
             topic::RedactedRoomTopicEventContent,
         },
@@ -48,21 +45,11 @@ async fn test_initial_events() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
+    let f = EventFactory::new();
     timeline
         .inner
         .add_events_at(
-            vec![
-                SyncTimelineEvent::new(
-                    timeline
-                        .event_builder
-                        .make_sync_message_event(*ALICE, RoomMessageEventContent::text_plain("A")),
-                ),
-                SyncTimelineEvent::new(
-                    timeline
-                        .event_builder
-                        .make_sync_message_event(*BOB, RoomMessageEventContent::text_plain("B")),
-                ),
-            ],
+            vec![f.text_msg("A").sender(*ALICE), f.text_msg("B").sender(*BOB)],
             TimelineEnd::Back,
             RemoteEventOrigin::Sync,
         )
@@ -393,10 +380,11 @@ async fn test_sanitized() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
+    let f = EventFactory::new();
+
     timeline
-        .handle_live_message_event(
-            &ALICE,
-            RoomMessageEventContent::text_html(
+        .handle_live_event(
+            f.text_html(
                 "\
                     @@Unknown text@@
                     Some text\n\n\
@@ -409,7 +397,8 @@ async fn test_sanitized() {
                     <p>Some text</p>\
                     <code unknown=\"code\">Some code</code>\
                 ",
-            ),
+            )
+            .sender(&ALICE),
         )
         .await;
 
@@ -435,12 +424,8 @@ async fn test_reply() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
-    timeline
-        .handle_live_message_event(
-            &ALICE,
-            RoomMessageEventContent::text_plain("I want you to reply"),
-        )
-        .await;
+    let f = EventFactory::new();
+    timeline.handle_live_event(f.text_msg("I want you to reply").sender(&ALICE)).await;
 
     let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
     let first_event = item.as_event().unwrap();
@@ -466,13 +451,12 @@ async fn test_reply() {
         "> <{first_event_sender}> I want you to reply\n\
          I'm replying!"
     );
-    let reply = assign!(RoomMessageEventContent::text_html(reply_plain, reply_formatted_body), {
-        relates_to: Some(Relation::Reply {
-            in_reply_to: InReplyTo::new(first_event_id.to_owned()),
-        }),
-    });
 
-    timeline.handle_live_message_event(&BOB, reply).await;
+    timeline
+        .handle_live_event(
+            f.text_html(reply_plain, reply_formatted_body).reply_to(first_event_id).sender(&BOB),
+        )
+        .await;
 
     let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
     assert_let!(TimelineItemContent::Message(message) = item.as_event().unwrap().content());
@@ -492,12 +476,8 @@ async fn test_thread() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
-    timeline
-        .handle_live_message_event(
-            &ALICE,
-            RoomMessageEventContent::text_plain("I want you to reply"),
-        )
-        .await;
+    let f = EventFactory::new();
+    timeline.handle_live_event(f.text_msg("I want you to reply").sender(&ALICE)).await;
 
     let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
     let first_event = item.as_event().unwrap();
@@ -506,13 +486,13 @@ async fn test_thread() {
     let day_divider = assert_next_matches!(stream, VectorDiff::PushFront { value } => value);
     assert!(day_divider.is_day_divider());
 
-    let reply = assign!(RoomMessageEventContent::text_plain("I'm replying in a thread"), {
-        relates_to: Some(Relation::Thread(
-            Thread::plain(first_event_id.to_owned(), first_event_id.to_owned()),
-        ))
-    });
-
-    timeline.handle_live_message_event(&BOB, reply).await;
+    timeline
+        .handle_live_event(
+            f.text_msg("I'm replying in a thread")
+                .sender(&BOB)
+                .in_thread(first_event_id, first_event_id),
+        )
+        .await;
 
     let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
     assert_let!(TimelineItemContent::Message(message) = item.as_event().unwrap().content());

crates/matrix-sdk-ui/src/timeline/tests/echo.rs

@@ -131,6 +131,7 @@ async fn test_remote_echo_full_trip() {
 async fn test_remote_echo_new_position() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
+    let f = EventFactory::new();
 
     // Given a local event…
     let txn_id = timeline
@@ -147,7 +148,7 @@ async fn test_remote_echo_new_position() {
     assert!(day_divider.is_day_divider());
 
     // … and another event that comes back before the remote echo
-    timeline.handle_live_message_event(&BOB, RoomMessageEventContent::text_plain("test")).await;
+    timeline.handle_live_event(f.text_msg("test").sender(&BOB)).await;
 
     // … and is inserted before the local echo item
     let bob_message = assert_next_matches!(stream, VectorDiff::PushFront { value } => value);
@@ -187,8 +188,9 @@ async fn test_day_divider_duplication() {
     let timeline = TestTimeline::new();
 
     // Given two remote events from one day, and a local event from another day…
-    timeline.handle_live_message_event(&BOB, RoomMessageEventContent::text_plain("A")).await;
-    timeline.handle_live_message_event(&BOB, RoomMessageEventContent::text_plain("B")).await;
+    let f = EventFactory::new().sender(&BOB);
+    timeline.handle_live_event(f.text_msg("A")).await;
+    timeline.handle_live_event(f.text_msg("B")).await;
     timeline
         .handle_local_event(AnyMessageLikeEventContent::RoomMessage(
             RoomMessageEventContent::text_plain("C"),

crates/matrix-sdk-ui/src/timeline/tests/edit.rs

@@ -14,15 +14,10 @@
 
 use assert_matches2::assert_let;
 use eyeball_im::VectorDiff;
+use matrix_sdk::test_utils::events::EventFactory;
 use matrix_sdk_test::{async_test, sync_timeline_event, ALICE};
 use ruma::{
-    assign,
-    events::{
-        relation::Replacement,
-        room::message::{
-            self, MessageType, RedactedRoomMessageEventContent, RoomMessageEventContent,
-        },
-    },
+    events::room::message::{MessageType, RedactedRoomMessageEventContent},
     server_name, EventId,
 };
 use stream_assert::assert_next_matches;
@@ -35,20 +30,21 @@ async fn test_live_redacted() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
+    let f = EventFactory::new();
     timeline
         .handle_live_redacted_message_event(*ALICE, RedactedRoomMessageEventContent::new())
         .await;
     let item = assert_next_matches!(stream, VectorDiff::PushBack { value } => value);
 
     let redacted_event_id = item.as_event().unwrap().event_id().unwrap();
 
-    let edit = assign!(RoomMessageEventContent::text_plain(" * test"), {
-        relates_to: Some(message::Relation::Replacement(Replacement::new(
-            redacted_event_id.to_owned(),
-            MessageType::text_plain("test").into(),
-        ))),
-    });
-    timeline.handle_live_message_event(&ALICE, edit).await;
+    timeline
+        .handle_live_event(
+            f.text_msg(" * test")
+                .sender(&ALICE)
+                .edit(redacted_event_id, MessageType::text_plain("test").into()),
+        )
+        .await;
 
     assert_eq!(timeline.inner.items().await.len(), 2);
 
@@ -61,13 +57,10 @@ async fn test_live_sanitized() {
     let timeline = TestTimeline::new();
     let mut stream = timeline.subscribe().await;
 
+    let f = EventFactory::new();
     timeline
-        .handle_live_message_event(
-            &ALICE,
-            RoomMessageEventContent::text_html(
-                "**original** message",
-                "<strong>original</strong> message",
-            ),
+        .handle_live_event(
+            f.text_html("**original** message", "<strong>original</strong> message").sender(&ALICE),
         )
         .await;
 
@@ -85,19 +78,16 @@ async fn test_live_sanitized() {
 
     let new_plain_content = "!!edited!! **better** message";
     let new_html_content = "<edited/> <strong>better</strong> message";
-    let edit = assign!(
-        RoomMessageEventContent::text_html(
-            format!("* {}", new_plain_content),
-            format!("* {}", new_html_content)
-        ),
-        {
-            relates_to: Some(message::Relation::Replacement(Replacement::new(
-                first_event_id.to_owned(),
-                MessageType::text_html(new_plain_content, new_html_content).into(),
-            ))),
-        }
-    );
-    timeline.handle_live_message_event(&ALICE, edit).await;
+    timeline
+        .handle_live_event(
+            f.text_html(format!("* {}", new_plain_content), format!("* {}", new_html_content))
+                .sender(&ALICE)
+                .edit(
+                    first_event_id,
+                    MessageType::text_html(new_plain_content, new_html_content).into(),
+                ),
+        )
+        .await;
 
     let item = assert_next_matches!(stream, VectorDiff::Set { index: 1, value } => value);
     let first_event = item.as_event().unwrap();