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

Author: dragonfly1033

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

@@ -44,6 +44,11 @@ use crate::{
     writer::SearchIndexWriter,
 };
 
+/// A struct to represent the operations on a [`RoomIndex`]
+pub(crate) enum RoomIndexOperation {
+    Add(TantivyDocument),
+}
+
 /// A struct that holds all data pertaining to a particular room's
 /// message index.
 pub struct RoomIndex {
@@ -130,10 +135,11 @@ impl RoomIndex {
         RoomIndex::new_with(index, schema, room_id)
     }
 
-    /// Add [`AnyMessageLikeEvent`] to [`RoomIndex`]
-    pub fn add_event(&mut self, event: AnyMessageLikeEvent) -> Result<(), IndexError> {
-        let doc = self.schema.make_doc(event)?;
-        self.writer.add_document(doc)?; // TODO: This is blocking. Handle it.
+    /// Handle [`AnyMessageLikeEvent`]
+    pub fn handle_event(&mut self, event: AnyMessageLikeEvent) -> Result<(), IndexError> {
+        match self.schema.handle_event(event)? {
+            RoomIndexOperation::Add(document) => self.writer.add_document(document)?,
+        };
         Ok(())
     }
 
@@ -206,7 +212,7 @@ mod tests {
     }
 
     #[test]
-    fn test_add_event() {
+    fn test_handle_event() {
         let room_id = room_id!("!room_id:localhost");
         let mut index =
             RoomIndex::new_in_ram(room_id).expect("failed to make index in ram: {index:?}");
@@ -218,7 +224,7 @@ mod tests {
             .sender(user_id!("@user_id:localhost"))
             .into_any_message_like_event();
 
-        index.add_event(event).expect("failed to add event: {res:?}");
+        index.handle_event(event).expect("failed to add event: {res:?}");
     }
 
     #[test]
@@ -231,7 +237,7 @@ mod tests {
         let event_id_2 = event_id!("$event_id_2:localhost");
         let event_id_3 = event_id!("$event_id_3:localhost");
 
-        index.add_event(
+        index.handle_event(
             EventFactory::new()
                 .text_msg("This is a sentence")
                 .event_id(event_id_1)
@@ -240,7 +246,7 @@ mod tests {
                 .into_any_message_like_event(),
         )?;
 
-        index.add_event(
+        index.handle_event(
             EventFactory::new()
                 .text_msg("All new words")
                 .event_id(event_id_2)
@@ -249,7 +255,7 @@ mod tests {
                 .into_any_message_like_event(),
         )?;
 
-        index.add_event(
+        index.handle_event(
             EventFactory::new()
                 .text_msg("A similar sentence")
                 .event_id(event_id_3)

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

@@ -25,26 +25,26 @@
 //! 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::{
-    MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId,
-    events::{
-        AnyMessageLikeEvent, MessageLikeEvent, MessageLikeEventContent, RedactContent,
-        RedactedMessageLikeEventContent, room::message::MessageType,
-    },
+use ruma::events::{
+    AnyMessageLikeEvent, MessageLikeEvent, MessageLikeEventContent, RedactContent,
+    RedactedMessageLikeEventContent, room::message::MessageType,
 };
 use tantivy::{
     DateTime, TantivyDocument, doc,
     schema::{DateOptions, DateTimePrecision, Field, INDEXED, STORED, STRING, Schema, TEXT},
 };
 
-use crate::error::{IndexError, IndexSchemaError};
+use crate::{
+    error::{IndexError, IndexSchemaError},
+    index::RoomIndexOperation,
+};
 
 pub(crate) trait MatrixSearchIndexSchema {
     fn new() -> Self;
     fn default_search_fields(&self) -> Vec<Field>;
     fn primary_key(&self) -> Field;
     fn as_tantivy_schema(&self) -> Schema;
-    fn make_doc(&self, event: AnyMessageLikeEvent) -> Result<TantivyDocument, IndexError>;
+    fn handle_event(&self, event: AnyMessageLikeEvent) -> Result<RoomIndexOperation, IndexError>;
 }
 
 #[derive(Debug, Clone)]
@@ -58,48 +58,30 @@ pub(crate) struct RoomMessageSchema {
 }
 
 impl RoomMessageSchema {
-    fn parse_event<C: MessageLikeEventContent + RedactContent, F>(
+    /// Given an [`AnyMessageLikeEvent`] 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>,
-        get_body: F,
-    ) -> Result<(OwnedEventId, String, MilliSecondsSinceUnixEpoch, OwnedUserId), IndexError>
+        get_body_from_content: F,
+    ) -> Result<TantivyDocument, IndexError>
     where
         <C as RedactContent>::Redacted: RedactedMessageLikeEventContent,
         F: FnOnce(&C) -> Result<String, IndexError>,
     {
         let unredacted = event.as_original().ok_or(IndexError::CannotIndexRedactedMessage)?;
 
-        let body = get_body(&unredacted.content)?;
+        let body = get_body_from_content(&unredacted.content)?;
 
-        Ok((
-            unredacted.event_id.clone(),
-            body,
-            unredacted.origin_server_ts,
-            unredacted.sender.clone(),
+        Ok(doc!(
+            self.event_id_field => unredacted.event_id.to_string(),
+            self.body_field => body,
+            self.date_field =>
+                DateTime::from_timestamp_millis(
+                    unredacted.origin_server_ts.get().into()),
+            self.sender_field => unredacted.sender.to_string(),
         ))
     }
-
-    fn parse_any_event(
-        &self,
-        event: AnyMessageLikeEvent,
-    ) -> Result<(OwnedEventId, String, MilliSecondsSinceUnixEpoch, OwnedUserId), IndexError> {
-        match event {
-            // old m.room.message behaviour
-            AnyMessageLikeEvent::RoomMessage(event) => {
-                self.parse_event(event, |content| match &content.msgtype {
-                    MessageType::Text(content) => Ok(content.body.clone()),
-                    _ => Err(IndexError::MessageTypeNotSupported),
-                })
-            }
-
-            // new m.message behaviour
-            AnyMessageLikeEvent::Message(event) => self.parse_event(event, |content| {
-                content.text.find_plain().ok_or(IndexError::EmptyMessage).map(|v| v.to_owned())
-            }),
-
-            _ => Err(IndexError::MessageTypeNotSupported),
-        }
-    }
 }
 
 impl MatrixSearchIndexSchema for RoomMessageSchema {
@@ -140,17 +122,25 @@ impl MatrixSearchIndexSchema for RoomMessageSchema {
         self.inner.clone()
     }
 
-    fn make_doc(&self, event: AnyMessageLikeEvent) -> Result<TantivyDocument, IndexError> {
-        let (event_id, body, timestamp, sender) = self.parse_any_event(event)?;
+    fn handle_event(&self, event: AnyMessageLikeEvent) -> Result<RoomIndexOperation, IndexError> {
+        match event {
+            // old m.room.message behaviour
+            AnyMessageLikeEvent::RoomMessage(event) => self
+                .make_doc(event, |content| match &content.msgtype {
+                    MessageType::Text(content) => Ok(content.body.clone()),
+                    _ => Err(IndexError::MessageTypeNotSupported),
+                })
+                .map(RoomIndexOperation::Add),
 
-        Ok(doc!(
-            self.event_id_field => event_id.to_string(),
-            self.body_field => body,
-            self.date_field =>
-                DateTime::from_timestamp_millis(
-                    timestamp.get().into()),
-            self.sender_field => sender.to_string(),
-        ))
+            // new m.message behaviour
+            AnyMessageLikeEvent::Message(event) => self
+                .make_doc(event, |content| {
+                    content.text.find_plain().ok_or(IndexError::EmptyMessage).map(|v| v.to_owned())
+                })
+                .map(RoomIndexOperation::Add),
+
+            _ => Err(IndexError::MessageTypeNotSupported),
+        }
     }
 }
 

crates/matrix-sdk/src/client/builder/mod.rs

@@ -503,8 +503,8 @@ impl ClientBuilder {
 
     /// The base directory in which each room's index directory will be stored.
     #[cfg(feature = "experimental-search")]
-    pub fn index_base_directory(mut self, path: SearchIndexStoreKind) -> Self {
-        self.search_index_store_kind = path;
+    pub fn search_index_store(mut self, kind: SearchIndexStoreKind) -> Self {
+        self.search_index_store_kind = kind;
         self
     }
 
@@ -610,10 +610,8 @@ impl ClientBuilder {
         let latest_events = OnceCell::new();
 
         #[cfg(feature = "experimental-search")]
-        let room_indexes = Arc::new(Mutex::new(HashMap::new()));
-
-        #[cfg(feature = "experimental-search")]
-        let search_index = SearchIndex::new(room_indexes, self.search_index_store_kind);
+        let search_index =
+            SearchIndex::new(Arc::new(Mutex::new(HashMap::new())), self.search_index_store_kind);
 
         let inner = ClientInner::new(
             auth_ctx,

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

@@ -1,4 +1,4 @@
-// Copyright 2024 The Matrix.org Foundation C.I.C.
+// Copyright 2025 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.
@@ -30,7 +30,7 @@ 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 tokio::sync::{Mutex, MutexGuard};
-use tracing::{debug, error, warn};
+use tracing::{debug, error};
 
 /// Type of location to store [`RoomIndex`]
 #[derive(Clone, Debug)]
@@ -85,8 +85,9 @@ impl SearchIndexGuard<'_> {
         Ok(index)
     }
 
-    /// Add [`AnyMessageLikeEvent`] to [`RoomIndex`] of given [`RoomId`]
-    pub(crate) fn index_event(
+    /// Handle an [`AnyMessageLikeEvent`] in the [`RoomIndex`] of a given
+    /// [`RoomId`]
+    pub(crate) fn handle_event(
         &mut self,
         event: AnyMessageLikeEvent,
         room_id: &RoomId,
@@ -97,7 +98,7 @@ impl SearchIndexGuard<'_> {
         }
 
         let index = self.index_map.get_mut(room_id).expect("index should exist");
-        let result = index.add_event(event);
+        let result = index.handle_event(event);
 
         match result {
             Ok(_) => {}
@@ -107,7 +108,7 @@ impl SearchIndexGuard<'_> {
                 debug!("failed to parse event for indexing: {result:?}")
             }
             Err(IndexError::TantivyError(err)) => {
-                error!("failed to add/commit event to index: {err:?}")
+                error!("failed to handle event in index: {err:?}")
             }
             Err(_) => error!("unexpected error during indexing: {result:?}"),
         }
@@ -130,7 +131,7 @@ impl SearchIndexGuard<'_> {
                 })
                 .ok()
         } else {
-            warn!("Tried to search in a room with no index");
+            debug!("Tried to search in a room with no index");
             None
         }
     }

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

@@ -542,14 +542,20 @@ impl RoomEventCacheInner {
         // Add all the events to the backend.
         trace!("adding new events");
 
+        #[cfg(feature = "experimental-search")]
+        let Some(room) = self.weak_room.get() else {
+            warn!("Couldn't get room while handling timeline");
+            return Err(EventCacheError::RoomNotFound { room_id: self.room_id.clone() });
+        };
+
         let (stored_prev_batch_token, timeline_event_diffs) = self
             .state
             .write()
             .await
             .handle_sync(
                 timeline,
                 #[cfg(feature = "experimental-search")]
-                &self.weak_room.get().expect("Should be able to get room"),
+                &room,
             )
             .await?;
 
@@ -1466,10 +1472,7 @@ mod private {
             };
 
             match maybe_try_event {
-                Some(Ok(event)) => match event {
-                    // TODO: Handle room redaction.
-                    AnyMessageLikeEvent::RoomRedaction(_) | _ => Some(event),
-                },
+                Some(Ok(event)) => Some(event),
                 Some(Err(e)) => {
                     warn!("failed to index event: {e:?}");
                     None
@@ -1479,13 +1482,13 @@ mod private {
         }
 
         #[cfg(feature = "experimental-search")]
-        async fn index_timeline_event(
+        async fn index_handle_timeline_event(
             &self,
             event: &TimelineEvent,
             room: &Room,
         ) -> Result<(), EventCacheError> {
             if let Some(message_event) = self.parse_timeline_event(event) {
-                room.index_event(message_event).await.map_err(EventCacheError::from)
+                room.index_handle_event(message_event).await.map_err(EventCacheError::from)
             } else {
                 Ok(())
             }
@@ -1511,7 +1514,7 @@ mod private {
 
                 // We can also add the event to the index.
                 #[cfg(feature = "experimental-search")]
-                if let Err(err) = self.index_timeline_event(&event, room).await {
+                if let Err(err) = self.index_handle_timeline_event(&event, room).await {
                     warn!("error while trying to index event: {err:?}");
                 }
 

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

@@ -3678,10 +3678,13 @@ impl Room {
         opts.send(self, event_id).await
     }
 
-    /// Add an [`AnyMessageLikeEvent`] to this room's [`RoomIndex`]
+    /// Handle an [`AnyMessageLikeEvent`] in this room's [`RoomIndex`]
     #[cfg(feature = "experimental-search")]
-    pub(crate) async fn index_event(&self, event: AnyMessageLikeEvent) -> Result<(), IndexError> {
-        self.client.search_index().lock().await.index_event(event, self.room_id())
+    pub(crate) async fn index_handle_event(
+        &self,
+        event: AnyMessageLikeEvent,
+    ) -> Result<(), IndexError> {
+        self.client.search_index().lock().await.handle_event(event, self.room_id())
     }
 
     /// Search this room's [`RoomIndex`] for query and return at most

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

@@ -768,7 +768,7 @@ async fn test_sending_message_indexes_message() {
 
     let response = room.search_index("this", 5).await.expect("search should have 1 result");
 
-    assert!(!response.is_empty(), "no results found {response:?}");
+    assert_eq!(response.len(), 1, "unexpected numbers of responses: {response:?}");
     assert_eq!(response[0], event_id, "event id doesn't match: {response:?}");
 }