fixup! fixup! fixup! fixup! fixup! fixup! test(sdk): Add integration test for search

Author: dragonfly1033

crates/matrix-sdk-search/src/error.rs

@@ -12,19 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache is an abstraction layer, sitting between the Rust SDK and a
-//! final client, that acts as a global observer of all the rooms, gathering and
-//! inferring some extra useful information about each room. In particular, this
-//! doesn't require subscribing to a specific room to get access to this
-//! information.
-//!
-//! It's intended to be fast, robust and easy to maintain, having learned from
-//! previous endeavours at implementing middle to high level features elsewhere
-//! in the SDK, notably in the UI's Timeline object.
-//!
-//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
-//! details about the historical reasons that led us to start writing this.
-
 use tantivy::{
     directory::error::OpenDirectoryError as TantivyOpenDirectoryError,
     query::QueryParserError as TantivyQueryParserError,

crates/matrix-sdk-search/src/index.rs

@@ -12,22 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache is an abstraction layer, sitting between the Rust SDK and a
-//! final client, that acts as a global observer of all the rooms, gathering and
-//! inferring some extra useful information about each room. In particular, this
-//! doesn't require subscribing to a specific room to get access to this
-//! information.
-//!
-//! It's intended to be fast, robust and easy to maintain, having learned from
-//! previous endeavours at implementing middle to high level features elsewhere
-//! in the SDK, notably in the UI's Timeline object.
-//!
-//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
-//! details about the historical reasons that led us to start writing this.
-
 use std::{fmt, fs, path::Path, sync::Arc};
 
-use ruma::{OwnedEventId, OwnedRoomId, RoomId, events::AnyMessageLikeEvent};
+use ruma::{OwnedEventId, OwnedRoomId, RoomId, events::AnySyncMessageLikeEvent};
 use tantivy::{
     Index, IndexReader, TantivyDocument,
     collector::TopDocs,
@@ -135,8 +122,8 @@ impl RoomIndex {
         RoomIndex::new_with(index, schema, room_id)
     }
 
-    /// Handle [`AnyMessageLikeEvent`]
-    pub fn handle_event(&mut self, event: AnyMessageLikeEvent) -> Result<(), IndexError> {
+    /// Handle [`AnySyncMessageLikeEvent`]
+    pub fn handle_event(&mut self, event: AnySyncMessageLikeEvent) -> Result<(), IndexError> {
         match self.schema.handle_event(event)? {
             RoomIndexOperation::Add(document) => self.writer.add_document(document)?,
         };
@@ -222,7 +209,7 @@ mod tests {
             .event_id(event_id!("$event_id:localhost"))
             .room(room_id)
             .sender(user_id!("@user_id:localhost"))
-            .into_any_message_like_event();
+            .into_any_sync_message_like_event();
 
         index.handle_event(event).expect("failed to add event: {res:?}");
     }
@@ -243,7 +230,7 @@ mod tests {
                 .event_id(event_id_1)
                 .room(room_id)
                 .sender(user_id!("@user_id:localhost"))
-                .into_any_message_like_event(),
+                .into_any_sync_message_like_event(),
         )?;
 
         index.handle_event(
@@ -252,7 +239,7 @@ mod tests {
                 .event_id(event_id_2)
                 .room(room_id)
                 .sender(user_id!("@user_id:localhost"))
-                .into_any_message_like_event(),
+                .into_any_sync_message_like_event(),
         )?;
 
         index.handle_event(
@@ -261,7 +248,7 @@ mod tests {
                 .event_id(event_id_3)
                 .room(room_id)
                 .sender(user_id!("@user_id:localhost"))
-                .into_any_message_like_event(),
+                .into_any_sync_message_like_event(),
         )?;
 
         index.commit_and_reload()?;

crates/matrix-sdk-search/src/schema.rs

@@ -12,22 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache is an abstraction layer, sitting between the Rust SDK and a
-//! final client, that acts as a global observer of all the rooms, gathering and
-//! inferring some extra useful information about each room. In particular, this
-//! doesn't require subscribing to a specific room to get access to this
-//! information.
-//!
-//! It's intended to be fast, robust and easy to maintain, having learned from
-//! previous endeavours at implementing middle to high level features elsewhere
-//! in the SDK, notably in the UI's Timeline object.
-//!
-//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
-//! details about the historical reasons that led us to start writing this.
-
 use ruma::events::{
-    AnyMessageLikeEvent, MessageLikeEvent, MessageLikeEventContent, RedactContent,
-    RedactedMessageLikeEventContent, room::message::MessageType,
+    AnySyncMessageLikeEvent, MessageLikeEventContent, RedactContent,
+    RedactedMessageLikeEventContent, SyncMessageLikeEvent, room::message::MessageType,
 };
 use tantivy::{
     DateTime, TantivyDocument, doc,
@@ -44,7 +31,10 @@ pub(crate) trait MatrixSearchIndexSchema {
     fn default_search_fields(&self) -> Vec<Field>;
     fn primary_key(&self) -> Field;
     fn as_tantivy_schema(&self) -> Schema;
-    fn handle_event(&self, event: AnyMessageLikeEvent) -> Result<RoomIndexOperation, IndexError>;
+    fn handle_event(
+        &self,
+        event: AnySyncMessageLikeEvent,
+    ) -> Result<RoomIndexOperation, IndexError>;
 }
 
 #[derive(Debug, Clone)]
@@ -58,11 +48,12 @@ pub(crate) struct RoomMessageSchema {
 }
 
 impl RoomMessageSchema {
-    /// Given an [`AnyMessageLikeEvent`] and a function to convert the content
-    /// into a String to be indexed, return a [`TantivyDocument`] to index.
+    /// Given an [`AnySyncMessageLikeEvent`] and a function to convert the
+    /// content into a String to be indexed, return a [`TantivyDocument`] to
+    /// index.
     fn make_doc<C: MessageLikeEventContent + RedactContent, F>(
         &self,
-        event: MessageLikeEvent<C>,
+        event: SyncMessageLikeEvent<C>,
         get_body_from_content: F,
     ) -> Result<TantivyDocument, IndexError>
     where
@@ -122,18 +113,21 @@ impl MatrixSearchIndexSchema for RoomMessageSchema {
         self.inner.clone()
     }
 
-    fn handle_event(&self, event: AnyMessageLikeEvent) -> Result<RoomIndexOperation, IndexError> {
+    fn handle_event(
+        &self,
+        event: AnySyncMessageLikeEvent,
+    ) -> Result<RoomIndexOperation, IndexError> {
         match event {
             // m.room.message behaviour
-            AnyMessageLikeEvent::RoomMessage(event) => self
+            AnySyncMessageLikeEvent::RoomMessage(event) => self
                 .make_doc(event, |content| match &content.msgtype {
                     MessageType::Text(content) => Ok(content.body.clone()),
                     _ => Err(IndexError::MessageTypeNotSupported),
                 })
                 .map(RoomIndexOperation::Add),
 
             // new MSC-1767 m.message behaviour
-            AnyMessageLikeEvent::Message(event) => self
+            AnySyncMessageLikeEvent::Message(event) => self
                 .make_doc(event, |content| {
                     content.text.find_plain().ok_or(IndexError::EmptyMessage).map(|v| v.to_owned())
                 })

crates/matrix-sdk-search/src/writer.rs

@@ -12,19 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache is an abstraction layer, sitting between the Rust SDK and a
-//! final client, that acts as a global observer of all the rooms, gathering and
-//! inferring some extra useful information about each room. In particular, this
-//! doesn't require subscribing to a specific room to get access to this
-//! information.
-//!
-//! It's intended to be fast, robust and easy to maintain, having learned from
-//! previous endeavours at implementing middle to high level features elsewhere
-//! in the SDK, notably in the UI's Timeline object.
-//!
-//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
-//! details about the historical reasons that led us to start writing this.
-
 use tantivy::{IndexWriter, TantivyDocument, TantivyError};
 
 use crate::{OpStamp, error::IndexError};

crates/matrix-sdk/src/client/search.rs

@@ -12,23 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-//! The event cache is an abstraction layer, sitting between the Rust SDK and a
-//! final client, that acts as a global observer of all the rooms, gathering and
-//! inferring some extra useful information about each room. In particular, this
-//! doesn't require subscribing to a specific room to get access to this
-//! information.
-//!
-//! It's intended to be fast, robust and easy to maintain, having learned from
-//! previous endeavours at implementing middle to high level features elsewhere
-//! in the SDK, notably in the UI's Timeline object.
-//!
-//! See the [github issue](https://github.com/matrix-org/matrix-rust-sdk/issues/3058) for more
-//! details about the historical reasons that led us to start writing this.
-
 use std::{collections::hash_map::HashMap, path::PathBuf, sync::Arc};
 
 use matrix_sdk_search::{error::IndexError, index::RoomIndex};
-use ruma::{events::AnyMessageLikeEvent, OwnedEventId, OwnedRoomId, RoomId};
+use ruma::{events::AnySyncMessageLikeEvent, OwnedEventId, OwnedRoomId, RoomId};
 use tokio::sync::{Mutex, MutexGuard};
 use tracing::{debug, error};
 
@@ -85,14 +72,14 @@ impl SearchIndexGuard<'_> {
         Ok(index)
     }
 
-    /// Handle an [`AnyMessageLikeEvent`] in the [`RoomIndex`] of a given
+    /// Handle an [`AnySyncMessageLikeEvent`] in the [`RoomIndex`] of a given
     /// [`RoomId`]
     ///
     /// This which will add/remove/edit an event in the index based on the
     /// event type.
     pub(crate) fn handle_event(
         &mut self,
-        event: AnyMessageLikeEvent,
+        event: AnySyncMessageLikeEvent,
         room_id: &RoomId,
     ) -> Result<(), IndexError> {
         if !self.index_map.contains_key(room_id) {

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

@@ -43,7 +43,7 @@ use tokio::sync::{
     broadcast::{Receiver, Sender},
     mpsc, Notify, RwLock,
 };
-use tracing::{instrument, trace, warn};
+use tracing::{debug, instrument, trace, warn};
 
 use super::{
     AutoShrinkChannelPayload, EventsOrigin, Result, RoomEventCacheGenericUpdate,
@@ -544,7 +544,7 @@ impl RoomEventCacheInner {
 
         #[cfg(feature = "experimental-search")]
         let Some(room) = self.weak_room.get() else {
-            warn!("Couldn't get room while handling timeline");
+            debug!("Couldn't get room while handling timeline");
             return Ok(());
         };
 
@@ -647,7 +647,7 @@ mod private {
     };
     use matrix_sdk_common::executor::spawn;
     #[cfg(feature = "experimental-search")]
-    use ruma::events::AnyMessageLikeEvent;
+    use ruma::events::{AnyMessageLikeEvent, AnySyncMessageLikeEvent};
     use ruma::{
         events::{
             relation::RelationType, room::redaction::SyncRoomRedactionEvent, AnySyncTimelineEvent,
@@ -1455,14 +1455,14 @@ mod private {
         }
 
         #[cfg(feature = "experimental-search")]
-        fn parse_timeline_event(&self, event: &TimelineEvent) -> Option<AnyMessageLikeEvent> {
+        fn parse_timeline_event(&self, event: &TimelineEvent) -> Option<AnySyncMessageLikeEvent> {
             let maybe_try_event = match &event.kind {
-                TimelineEventKind::Decrypted(d) => Some(d.event.deserialize()),
+                TimelineEventKind::Decrypted(d) => {
+                    Some(d.event.deserialize().map(AnyMessageLikeEvent::into))
+                }
                 TimelineEventKind::PlainText { event } => match event.deserialize() {
                     Ok(event_obj) => match event_obj {
-                        AnySyncTimelineEvent::MessageLike(sync_event) => {
-                            Some(Ok(sync_event.into_full_event(self.room.clone())))
-                        }
+                        AnySyncTimelineEvent::MessageLike(sync_event) => Some(Ok(sync_event)),
                         AnySyncTimelineEvent::State(_) => None,
                     },
                     Err(e) => Some(Err(e)),
@@ -1668,9 +1668,9 @@ mod private {
 
             // It is a `m.room.redaction`! We can deserialize it entirely.
 
-            let Ok(AnySyncTimelineEvent::MessageLike(
-                ruma::events::AnySyncMessageLikeEvent::RoomRedaction(redaction),
-            )) = raw_event.deserialize()
+            let Ok(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(
+                redaction,
+            ))) = raw_event.deserialize()
             else {
                 return Ok(());
             };

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

@@ -64,11 +64,10 @@ use reply::Reply;
 #[cfg(feature = "unstable-msc4274")]
 use ruma::events::room::message::GalleryItemType;
 #[cfg(feature = "experimental-search")]
-use ruma::events::AnyMessageLikeEvent;
+use ruma::events::AnySyncMessageLikeEvent;
 #[cfg(feature = "e2e-encryption")]
 use ruma::events::{
-    room::encrypted::OriginalSyncRoomEncryptedEvent, AnySyncMessageLikeEvent, AnySyncTimelineEvent,
-    SyncMessageLikeEvent,
+    room::encrypted::OriginalSyncRoomEncryptedEvent, AnySyncTimelineEvent, SyncMessageLikeEvent,
 };
 use ruma::{
     api::client::{
@@ -3678,12 +3677,15 @@ impl Room {
         opts.send(self, event_id).await
     }
 
-    /// Handle an [`AnyMessageLikeEvent`] in this room's [`RoomIndex`].
+    /// Handle an [`AnySyncMessageLikeEvent`] in this room's [`RoomIndex`].
     ///
     /// This which will add/remove/edit an event in the index based on the
     /// event type.
     #[cfg(feature = "experimental-search")]
-    pub(crate) async fn index_event(&self, event: AnyMessageLikeEvent) -> Result<(), IndexError> {
+    pub(crate) async fn index_event(
+        &self,
+        event: AnySyncMessageLikeEvent,
+    ) -> Result<(), IndexError> {
         self.client.search_index().lock().await.handle_event(event, self.room_id())
     }
 

testing/matrix-sdk-test/src/event_factory.rs

@@ -28,8 +28,8 @@ use ruma::{
     OwnedRoomId, OwnedTransactionId, OwnedUserId, OwnedVoipId, RoomId, RoomVersionId,
     TransactionId, UInt, UserId, VoipVersionId,
     events::{
-        AnyMessageLikeEvent, AnyStateEvent, AnySyncMessageLikeEvent, AnySyncStateEvent,
-        AnySyncTimelineEvent, AnyTimelineEvent, BundledMessageLikeRelations, False, Mentions,
+        AnyStateEvent, AnySyncMessageLikeEvent, AnySyncStateEvent, AnySyncTimelineEvent,
+        AnyTimelineEvent, BundledMessageLikeRelations, False, Mentions,
         RedactedMessageLikeEventContent, RedactedStateEventContent, StateEventContent,
         StaticEventContent,
         beacon::BeaconEventContent,
@@ -321,7 +321,7 @@ where
         self.into_raw()
     }
 
-    pub fn into_any_message_like_event(self) -> AnyMessageLikeEvent {
+    pub fn into_any_sync_message_like_event(self) -> AnySyncMessageLikeEvent {
         self.into_raw().deserialize().expect("expected message like event")
     }