sdk: add RequestConfig to Room::event_with_context to match Room::event, save its results to the event cache too.

Author: jmartinesp

crates/matrix-sdk-ui/src/notification_client.rs

@@ -478,7 +478,7 @@ impl NotificationClient {
             return Err(Error::UnknownRoom);
         };
 
-        let response = room.event_with_context(event_id, true, uint!(0)).await?;
+        let response = room.event_with_context(event_id, true, uint!(0), None).await?;
 
         let mut timeline_event = response.event.ok_or(Error::ContextMissingEvent)?;
         let state_events = response.state;

crates/matrix-sdk/src/event_cache/mod.rs

@@ -554,15 +554,10 @@ impl RoomEventCache {
     // be no distinction between the linked chunk and the separate cache.
     pub(crate) async fn save_event(&self, event: SyncTimelineEvent) {
         if let Some(event_id) = event.event_id() {
-            let mut cache = self.inner
-                .all_events_cache
-                .write()
-                .await;
+            let mut cache = self.inner.all_events_cache.write().await;
 
             self.inner.append_related_event(&mut cache, &event);
-            cache.events
-                .insert(event_id, (self.inner.room_id.clone(), event));
-
+            cache.events.insert(event_id, (self.inner.room_id.clone(), event));
         } else {
             warn!("couldn't save event without event id in the event cache");
         }

crates/matrix-sdk/src/event_cache/paginator.rs

@@ -469,24 +469,24 @@ impl PaginableRoom for Room {
         lazy_load_members: bool,
         num_events: UInt,
     ) -> Result<EventWithContextResponse, PaginatorError> {
-        let response = match self.event_with_context(event_id, lazy_load_members, num_events).await
-        {
-            Ok(result) => result,
-
-            Err(err) => {
-                // If the error was a 404, then the event wasn't found on the server; special
-                // case this to make it easy to react to such an error.
-                if let Some(error) = err.as_client_api_error() {
-                    if error.status_code == 404 {
-                        // Event not found
-                        return Err(PaginatorError::EventNotFound(event_id.to_owned()));
+        let response =
+            match self.event_with_context(event_id, lazy_load_members, num_events, None).await {
+                Ok(result) => result,
+
+                Err(err) => {
+                    // If the error was a 404, then the event wasn't found on the server; special
+                    // case this to make it easy to react to such an error.
+                    if let Some(error) = err.as_client_api_error() {
+                        if error.status_code == 404 {
+                            // Event not found
+                            return Err(PaginatorError::EventNotFound(event_id.to_owned()));
+                        }
                     }
-                }
 
-                // Otherwise, just return a wrapped error.
-                return Err(PaginatorError::SdkError(Box::new(err)));
-            }
-        };
+                    // Otherwise, just return a wrapped error.
+                    return Err(PaginatorError::SdkError(Box::new(err)));
+                }
+            };
 
         Ok(response)
     }

crates/matrix-sdk/src/room/mod.rs

@@ -23,7 +23,7 @@ use matrix_sdk_base::{
     ComposerDraft, RoomInfoNotableUpdateReasons, RoomMemberships, StateChanges, StateStoreDataKey,
     StateStoreDataValue,
 };
-use matrix_sdk_common::timeout::timeout;
+use matrix_sdk_common::{deserialized_responses::SyncTimelineEvent, timeout::timeout};
 use mime::Mime;
 #[cfg(feature = "e2e-encryption")]
 use ruma::events::{
@@ -417,6 +417,7 @@ impl Room {
         event_id: &EventId,
         lazy_load_members: bool,
         context_size: UInt,
+        request_config: Option<RequestConfig>,
     ) -> Result<EventWithContextResponse> {
         let mut request =
             context::get_context::v3::Request::new(self.room_id().to_owned(), event_id.to_owned());
@@ -428,7 +429,7 @@ impl Room {
                 LazyLoadOptions::Enabled { include_redundant_members: false };
         }
 
-        let response = self.client.send(request, None).await?;
+        let response = self.client.send(request, request_config).await?;
 
         let target_event = if let Some(event) = response.event {
             Some(self.try_decrypt_event(event).await?)
@@ -445,6 +446,24 @@ impl Room {
         )
         .await?;
 
+        // Save the loaded events into the event cache, if it's set up.
+        if let Ok((cache, _handles)) = self.event_cache().await {
+            let mut events_to_save: Vec<SyncTimelineEvent> = Vec::new();
+            if let Some(event) = &target_event {
+                events_to_save.push(event.clone().into());
+            }
+
+            for event in &events_before {
+                events_to_save.push(event.clone().into());
+            }
+
+            for event in &events_after {
+                events_to_save.push(event.clone().into());
+            }
+
+            cache.save_events(events_to_save).await;
+        }
+
         Ok(EventWithContextResponse {
             event: target_event,
             events_before,

crates/matrix-sdk/tests/integration/room/common.rs

@@ -1,7 +1,11 @@
 use std::{iter, time::Duration};
 
 use assert_matches2::assert_let;
-use matrix_sdk::{config::SyncSettings, room::RoomMember, DisplayName, RoomMemberships};
+use js_int::uint;
+use matrix_sdk::{
+    config::SyncSettings, room::RoomMember, test_utils::events::EventFactory, DisplayName,
+    RoomMemberships,
+};
 use matrix_sdk_test::{
     async_test, bulk_room_members, sync_state_event, sync_timeline_event, test_json,
     GlobalAccountDataTestEvent, JoinedRoomBuilder, LeftRoomBuilder, StateTestEvent,
@@ -10,14 +14,14 @@ use matrix_sdk_test::{
 use ruma::{
     event_id,
     events::{
-        room::member::MembershipState, AnyStateEvent, AnySyncStateEvent, AnyTimelineEvent,
-        StateEventType,
+        room::{member::MembershipState, message::RoomMessageEventContent},
+        AnyStateEvent, AnySyncStateEvent, AnyTimelineEvent, StateEventType,
     },
     room_id,
 };
 use serde_json::json;
 use wiremock::{
-    matchers::{body_json, header, method, path_regex},
+    matchers::{body_json, header, method, path, path_regex},
     Mock, ResponseTemplate,
 };
 
@@ -620,6 +624,9 @@ async fn test_event() {
     let event_id = event_id!("$foun39djjod0f");
 
     let (client, server) = logged_in_client_with_server().await;
+    let cache = client.event_cache();
+    let _ = cache.subscribe();
+
     let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
 
     let mut sync_builder = SyncResponseBuilder::new();
@@ -668,6 +675,76 @@ async fn test_event() {
     let push_actions = timeline_event.push_actions.unwrap();
     assert!(push_actions.iter().any(|a| a.is_highlight()));
     assert!(push_actions.iter().any(|a| a.should_notify()));
+
+    // Requested event was saved to the cache
+    assert!(cache.event(event_id).await.is_some());
+}
+
+#[async_test]
+async fn test_event_with_context() {
+    let event_id = event_id!("$cur1234");
+    let prev_event_id = event_id!("$prev1234");
+    let next_event_id = event_id!("$next_1234");
+
+    let (client, server) = logged_in_client_with_server().await;
+    let cache = client.event_cache();
+    let _ = cache.subscribe();
+
+    let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
+
+    let mut sync_builder = SyncResponseBuilder::new();
+    sync_builder
+        // We need the member event and power levels locally so the push rules processor works.
+        .add_joined_room(
+            JoinedRoomBuilder::new(&DEFAULT_TEST_ROOM_ID)
+                .add_state_event(StateTestEvent::Member)
+                .add_state_event(StateTestEvent::PowerLevels),
+        );
+
+    mock_sync(&server, sync_builder.build_json_sync_response(), None).await;
+    let _response = client.sync_once(sync_settings.clone()).await.unwrap();
+    server.reset().await;
+
+    let room = client.get_room(&DEFAULT_TEST_ROOM_ID).unwrap();
+    let room_id = room.room_id();
+
+    let f = EventFactory::new().room(room_id).sender(*BOB);
+    let event =
+        f.event(RoomMessageEventContent::text_plain("The requested message")).event_id(event_id);
+    let event_before =
+        f.event(RoomMessageEventContent::text_plain("A previous message")).event_id(prev_event_id);
+    let event_next =
+        f.event(RoomMessageEventContent::text_plain("A newer message")).event_id(next_event_id);
+    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": [event_before.into_raw_timeline()],
+            "event": event.into_raw_timeline(),
+            "events_after": [event_next.into_raw_timeline()],
+            "state": [],
+        })))
+        .mount(&server)
+        .await;
+
+    let context_ret = room.event_with_context(event_id, false, uint!(1), None).await.unwrap();
+
+    assert_let!(Some(timeline_event) = context_ret.event);
+    assert_let!(Ok(event) = timeline_event.event.deserialize());
+    assert_eq!(event.event_id(), event_id);
+
+    assert_eq!(1, context_ret.events_before.len());
+    assert_let!(Ok(event) = context_ret.events_before[0].event.deserialize());
+    assert_eq!(event.event_id(), prev_event_id);
+
+    assert_eq!(1, context_ret.events_after.len());
+    assert_let!(Ok(event) = context_ret.events_after[0].event.deserialize());
+    assert_eq!(event.event_id(), next_event_id);
+
+    // Requested event and their context ones were saved to the cache
+    assert!(cache.event(event_id).await.is_some());
+    assert!(cache.event(prev_event_id).await.is_some());
+    assert!(cache.event(next_event_id).await.is_some());
 }
 
 #[async_test]

testing/matrix-sdk-integration-testing/src/tests/room.rs

@@ -94,7 +94,7 @@ async fn test_event_with_context() -> Result<()> {
 
     {
         // First /context query: only the target event, no context around it.
-        let response = room.event_with_context(&event_id, false, uint!(0)).await?;
+        let response = room.event_with_context(&event_id, false, uint!(0), None).await?;
 
         let target = response
             .event
@@ -113,7 +113,8 @@ async fn test_event_with_context() -> Result<()> {
 
     {
         // Next query: an event that doesn't exist (hopefully!).
-        let response = room.event_with_context(event_id!("$lolololol"), false, uint!(0)).await;
+        let response =
+            room.event_with_context(event_id!("$lolololol"), false, uint!(0), None).await;
 
         // Servers answers with 404.
         assert_let!(Err(err) = response);
@@ -123,7 +124,7 @@ async fn test_event_with_context() -> Result<()> {
     {
         // Next query: target event with a context of 3 events. There
         // should be some previous and next tokens.
-        let response = room.event_with_context(&event_id, false, uint!(3)).await?;
+        let response = room.event_with_context(&event_id, false, uint!(3), None).await?;
 
         let target = response
             .event