test: Update tests according to last patches.

Author: Hywan

crates/matrix-sdk-base/src/store/integration_tests.rs

@@ -1611,7 +1611,7 @@ impl StateStoreIntegrationTests for DynStateStore {
             room_id,
             txn0.clone(),
             MilliSecondsSinceUnixEpoch::now(),
-            event0.into(),
+            event0.clone().into(),
             0,
         )
         .await?;
@@ -1639,15 +1639,16 @@ impl StateStoreIntegrationTests for DynStateStore {
         assert_matches!(dependents[0].kind, DependentQueuedRequestKind::RedactEvent);
 
         // Update the event id.
+        let (event, event_type) = event0.raw();
         let event_id = owned_event_id!("$1");
         let num_updated = self
             .mark_dependent_queued_requests_as_ready(
                 room_id,
                 &txn0,
                 SentRequestKey::Event {
                     event_id: event_id.clone(),
-                    event: Raw::from_json_string("{}".to_string()),
-                    event_type: "m.foo".to_string(),
+                    event: event.clone(),
+                    event_type: event_type.to_owned(),
                 },
             )
             .await?;
@@ -1658,9 +1659,18 @@ impl StateStoreIntegrationTests for DynStateStore {
         assert_eq!(dependents.len(), 1);
         assert_eq!(dependents[0].parent_transaction_id, txn0);
         assert_eq!(dependents[0].own_transaction_id, child_txn);
-        assert_matches!(dependents[0].parent_key.as_ref(), Some(SentRequestKey::Event(eid)) => {
-            assert_eq!(*eid, event_id);
-        });
+        assert_matches!(
+            dependents[0].parent_key.as_ref(),
+            Some(SentRequestKey::Event {
+                event_id: received_event_id,
+                event: received_event,
+                event_type: received_event_type
+            }) => {
+                assert_eq!(received_event_id, &event_id);
+                assert_eq!(received_event.json().to_string(), event.json().to_string());
+                assert_eq!(received_event_type.as_str(), event_type);
+            }
+        );
         assert_matches!(dependents[0].kind, DependentQueuedRequestKind::RedactEvent);
 
         // Now remove it.

crates/matrix-sdk-ui/src/timeline/latest_event.rs

@@ -205,9 +205,7 @@ mod tests {
     use ruma::{
         MilliSecondsSinceUnixEpoch, event_id,
         events::{AnyMessageLikeEventContent, room::message::RoomMessageEventContent},
-        room_id,
-        serde::Raw,
-        uint, user_id,
+        room_id, uint, user_id,
     };
 
     use super::{

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

@@ -18,15 +18,13 @@ use assert_matches::assert_matches;
 use assert_matches2::assert_let;
 use eyeball_im::VectorDiff;
 use futures_util::StreamExt;
-use matrix_sdk::{
-    executor::spawn, ruma::MilliSecondsSinceUnixEpoch, test_utils::mocks::MatrixMockServer,
-};
+use matrix_sdk::{executor::spawn, test_utils::mocks::MatrixMockServer};
 use matrix_sdk_test::{JoinedRoomBuilder, async_test, event_factory::EventFactory};
 use matrix_sdk_ui::timeline::{EventSendState, RoomExt};
 use ruma::{
     event_id,
     events::room::message::{MessageType, RoomMessageEventContent},
-    room_id, uint, user_id,
+    room_id, user_id,
 };
 use serde_json::json;
 use stream_assert::{assert_next_matches, assert_pending};
@@ -82,43 +80,70 @@ async fn test_echo() {
     send_hdl.await.unwrap().unwrap();
 
     assert_let!(Some(timeline_updates) = timeline_stream.next().await);
-    assert_eq!(timeline_updates.len(), 1);
+    assert_eq!(timeline_updates.len(), 5);
 
+    // The `EventSendState` has been updated.
     assert_let!(VectorDiff::Set { index: 1, value: sent_confirmation } = &timeline_updates[0]);
     let item = sent_confirmation.as_event().unwrap();
     assert_matches!(item.send_state(), Some(EventSendState::Sent { .. }));
     assert_eq!(item.event_id(), Some(event_id));
 
+    // The local event is removed.
+    assert_matches!(&timeline_updates[1], VectorDiff::Remove { index: 1 });
+
+    // The new event is inserted in the Event Cache: it comes as a remote event.
+    assert_let!(VectorDiff::PushFront { value: remote_event } = &timeline_updates[2]);
+    let item = remote_event.as_event().unwrap();
+    assert_let!(Some(msg) = item.content().as_message());
+    assert_let!(MessageType::Text(text) = msg.msgtype());
+    assert_eq!(text.body, "Hello, World!");
+    assert_eq!(item.event_id(), Some(event_id));
+
+    // The date divider is adjusted.
+    assert_let!(VectorDiff::PushFront { value: date_divider } = &timeline_updates[3]);
+    assert!(date_divider.is_date_divider());
+    assert_matches!(&timeline_updates[4], VectorDiff::Remove { index: 2 });
+
+    assert_pending!(timeline_stream);
+
+    let another_event_id = event_id!("$ev1");
     let f = EventFactory::new();
     server
         .sync_room(
             &client,
-            JoinedRoomBuilder::new(room_id).add_timeline_event(
-                f.text_msg("Hello, World!")
-                    .sender(user_id!("@example:localhost"))
-                    .event_id(event_id)
-                    .server_ts(152038280)
-                    .unsigned_transaction_id(txn_id),
-            ),
+            JoinedRoomBuilder::new(room_id)
+                .add_timeline_event(
+                    f.text_msg("Hello, World!")
+                        .sender(user_id!("@example:localhost"))
+                        .event_id(event_id)
+                        .server_ts(152038280)
+                        .unsigned_transaction_id(txn_id),
+                )
+                .add_timeline_event(
+                    f.text_msg("Raclette")
+                        .sender(user_id!("@example:localhost"))
+                        .event_id(another_event_id)
+                        .server_ts(152038281),
+                ),
         )
         .await;
 
+    // The Event Cache deduplicates the first event, but we receive a second one.
     assert_let!(Some(timeline_updates) = timeline_stream.next().await);
-    assert_eq!(timeline_updates.len(), 4);
+    assert_eq!(timeline_updates.len(), 5);
 
-    // Local echo is replaced with the remote echo.
-    assert_let!(VectorDiff::Remove { index: 1 } = &timeline_updates[0]);
+    assert_matches!(&timeline_updates[0], VectorDiff::Remove { index: 1 });
 
-    assert_let!(VectorDiff::PushFront { value: remote_echo } = &timeline_updates[1]);
-    let item = remote_echo.as_event().unwrap();
-    assert!(item.is_own());
-    assert_eq!(item.timestamp(), MilliSecondsSinceUnixEpoch(uint!(152038280)));
+    assert_let!(VectorDiff::PushFront { value: first_event } = &timeline_updates[1]);
+    assert_eq!(first_event.as_event().unwrap().event_id(), Some(event_id));
+
+    assert_let!(VectorDiff::Insert { index: 1, value: second_event } = &timeline_updates[2]);
+    assert_eq!(second_event.as_event().unwrap().event_id(), Some(another_event_id));
 
-    // The date divider is also replaced.
-    assert_let!(VectorDiff::PushFront { value: date_divider } = &timeline_updates[2]);
+    assert_let!(VectorDiff::PushFront { value: date_divider } = &timeline_updates[3]);
     assert!(date_divider.is_date_divider());
 
-    assert_let!(VectorDiff::Remove { index: 2 } = &timeline_updates[3]);
+    assert_matches!(&timeline_updates[4], VectorDiff::Remove { index: 3 });
 
     assert_pending!(timeline_stream);
 }

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

@@ -257,17 +257,26 @@ async fn test_edit_local_echo() {
     timeline.room().send_queue().set_enabled(true);
 
     assert_let!(Some(timeline_updates) = timeline_stream.next().await);
-    assert_eq!(timeline_updates.len(), 1);
+    assert_eq!(timeline_updates.len(), 5);
 
     // Observe the event being sent, and replacing the local echo.
     assert_let!(VectorDiff::Set { index: 1, value: item } = &timeline_updates[0]);
-
     let item = item.as_event().unwrap();
     assert!(item.is_local_echo());
-
     let edit_message = item.content().as_message().unwrap();
     assert_eq!(edit_message.body(), "hello, world");
 
+    // Since the event is sent, it's inserted in the Event Cache, which
+    // transforms it as a remote event.
+    assert_matches!(&timeline_updates[1], VectorDiff::Remove { index: 1 });
+    assert_let!(VectorDiff::PushFront { value: remote_event } = &timeline_updates[2]);
+    assert_eq!(remote_event.as_event().unwrap().event_id().unwrap(), "$1");
+
+    // The date divider is adjusted.
+    assert_let!(VectorDiff::PushFront { value: date_divider } = &timeline_updates[3]);
+    assert!(date_divider.is_date_divider());
+    assert_matches!(&timeline_updates[4], VectorDiff::Remove { index: 2 });
+
     // No new updates.
     assert_pending!(timeline_stream);
 }

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

@@ -202,6 +202,14 @@ async fn test_send_attachment_from_file() -> TestResult {
         assert_matches!(item.send_state(), Some(EventSendState::Sent{ event_id }) => {
             assert_eq!(event_id, event_id!("$media"));
         });
+
+        // Since it's sent, it's inserted in the Event Cache, and becomes a
+        // remote event.
+        assert_let_timeout!(Some(VectorDiff::Remove { index: 1 }) = timeline_stream.next());
+        assert_let_timeout!(
+            Some(VectorDiff::Insert { index: 1, value: remote_event }) = timeline_stream.next()
+        );
+        assert_eq!(remote_event.event_id().unwrap(), event_id!("$media"));
     }
 
     // That's all, folks!
@@ -336,6 +344,14 @@ async fn test_send_attachment_from_bytes() -> TestResult {
         assert_matches!(item.send_state(), Some(EventSendState::Sent{ event_id }) => {
             assert_eq!(event_id, event_id!("$media"));
         });
+
+        // Since it's sent, it's inserted in the Event Cache, and becomes a
+        // remote event.
+        assert_let_timeout!(Some(VectorDiff::Remove { index: 1 }) = timeline_stream.next());
+        assert_let_timeout!(
+            Some(VectorDiff::Insert { index: 1, value: remote_event }) = timeline_stream.next()
+        );
+        assert_eq!(remote_event.event_id().unwrap(), event_id!("$media"));
     }
 
     // That's all, folks!
@@ -508,6 +524,14 @@ async fn test_send_gallery_from_bytes() -> TestResult {
         assert_matches!(item.send_state(), Some(EventSendState::Sent{ event_id }) => {
             assert_eq!(event_id, event_id!("$media"));
         });
+
+        // Since it's sent, it's inserted in the Event Cache, and becomes a
+        // remote event.
+        assert_let_timeout!(Some(VectorDiff::Remove { index: 1 }) = timeline_stream.next());
+        assert_let_timeout!(
+            Some(VectorDiff::Insert { index: 1, value: remote_event }) = timeline_stream.next()
+        );
+        assert_eq!(remote_event.event_id().unwrap(), event_id!("$media"));
     }
 
     // That's all, folks!

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

@@ -386,7 +386,8 @@ async fn test_redact_local_sent_message() {
     let (_, mut timeline_stream) = timeline.subscribe().await;
 
     // Mock event sending.
-    server.mock_room_send().ok(event_id!("$wWgymRfo7ri1uQx0NXO40vLJ")).mock_once().mount().await;
+    let event_id = event_id!("$ev0");
+    server.mock_room_send().ok(event_id).mock_once().mount().await;
 
     // Send the event so it's added to the send queue as a local event.
     timeline
@@ -408,19 +409,27 @@ async fn test_redact_local_sent_message() {
     assert!(date_divider.is_date_divider());
 
     assert_let!(Some(timeline_updates) = timeline_stream.next().await);
-    assert_eq!(timeline_updates.len(), 1);
+    assert_eq!(timeline_updates.len(), 5);
 
     // We receive an update in the timeline from the send queue.
-    assert_let!(VectorDiff::Set { index, value: item } = &timeline_updates[0]);
-    assert_eq!(*index, 1);
-
-    assert_pending!(timeline_stream);
-
-    // Check the event is sent but still considered local.
+    assert_let!(VectorDiff::Set { index: 1, value: item } = &timeline_updates[0]);
     let event = item.as_event().unwrap();
     assert!(event.is_local_echo());
     assert_matches!(event.send_state(), Some(EventSendState::Sent { .. }));
 
+    // And then it's inserted in the Event Cache, and considered remote.
+    assert_matches!(&timeline_updates[1], VectorDiff::Remove { index: 1 });
+    assert_let!(VectorDiff::PushFront { value: remote_event } = &timeline_updates[2]);
+    assert_eq!(remote_event.as_event().unwrap().event_id(), Some(event_id));
+
+    // The date divider is adjusted.
+    assert_let!(VectorDiff::PushFront { value: date_divider } = &timeline_updates[3]);
+    assert!(date_divider.is_date_divider());
+
+    assert_matches!(&timeline_updates[4], VectorDiff::Remove { index: 2 });
+
+    assert_pending!(timeline_stream);
+
     // Mock the redaction response for the event we just sent. Ensure it's called
     // once.
     server.mock_room_redact().ok(event_id!("$redaction_event_id")).mock_once().mount().await;