test(base): Add test to populate a store

Author: zecakeh

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

@@ -613,7 +613,7 @@ mod test {
     use matrix_sdk_test::{async_test, test_json};
     use ruma::{
         api::client::r0::media::get_content_thumbnail::Method,
-        events::{AnyEphemeralRoomEventContent, AnySyncEphemeralRoomEvent},
+        events::{AnyEphemeralRoomEventContent, AnySyncEphemeralRoomEvent, EventType},
         mxc_uri,
         receipt::ReceiptType,
         uint,
@@ -623,7 +623,9 @@ mod test {
     use super::{MemoryStore, StateChanges};
     use crate::{
         media::{MediaFormat, MediaRequest, MediaThumbnailSize, MediaType},
-        store::test::{first_receipt_event_id, room_id, second_receipt_event_id, user_id},
+        store::test::{
+            first_receipt_event_id, populated_store, room_id, second_receipt_event_id, user_id,
+        },
     };
 
     #[async_test]
@@ -754,4 +756,45 @@ mod test {
         assert!(store.get_media_content(&request_file).await.unwrap().is_none());
         assert!(store.get_media_content(&request_thumbnail).await.unwrap().is_none());
     }
+
+    #[async_test]
+    async fn test_populate_store() {
+        let room_id = room_id();
+        let user_id = user_id();
+
+        let store = populated_store(Box::new(MemoryStore::new())).await.unwrap();
+
+        assert!(store.get_sync_token().await.unwrap().is_some());
+        assert!(store.get_presence_event(user_id).await.unwrap().is_some());
+        assert_eq!(store.get_room_infos().await.unwrap().len(), 2);
+        assert_eq!(store.get_stripped_room_infos().await.unwrap().len(), 1);
+        assert!(store.get_account_data_event(EventType::PushRules).await.unwrap().is_some());
+
+        assert!(store.get_state_event(room_id, EventType::RoomName, "").await.unwrap().is_some());
+        assert_eq!(store.get_state_events(room_id, EventType::RoomTopic).await.unwrap().len(), 1);
+        assert!(store.get_profile(room_id, user_id).await.unwrap().is_some());
+        assert!(store.get_member_event(room_id, user_id).await.unwrap().is_some());
+        assert_eq!(store.get_user_ids(room_id).await.unwrap().len(), 2);
+        assert_eq!(store.get_invited_user_ids(room_id).await.unwrap().len(), 1);
+        assert_eq!(store.get_joined_user_ids(room_id).await.unwrap().len(), 1);
+        assert_eq!(store.get_users_with_display_name(room_id, "example").await.unwrap().len(), 2);
+        assert!(store
+            .get_room_account_data_event(room_id, EventType::Tag)
+            .await
+            .unwrap()
+            .is_some());
+        assert!(store
+            .get_user_room_receipt_event(room_id, ReceiptType::Read, user_id)
+            .await
+            .unwrap()
+            .is_some());
+        assert_eq!(
+            store
+                .get_event_room_receipt_events(room_id, ReceiptType::Read, first_receipt_event_id())
+                .await
+                .unwrap()
+                .len(),
+            1
+        );
+    }
 }

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

@@ -581,21 +581,181 @@ impl StateChanges {
 
 #[cfg(test)]
 mod test {
-    use ruma::{event_id, room_id, user_id, EventId, RoomId, UserId};
+    use std::collections::{BTreeMap, BTreeSet};
+
+    use matrix_sdk_common::deserialized_responses::{MemberEvent, StrippedMemberEvent};
+    use matrix_sdk_test::test_json;
+    use ruma::{
+        device_id, event_id,
+        events::{
+            presence::PresenceEvent, AnyEphemeralRoomEventContent, AnyGlobalAccountDataEvent,
+            AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncEphemeralRoomEvent,
+            AnySyncStateEvent, EventContent,
+        },
+        room_id,
+        serde::Raw,
+        user_id, EventId, RoomId, UserId,
+    };
+    use serde_json::Value as JsonValue;
+
+    use super::{Result, StateChanges, StateStore, Store};
+    use crate::{RoomType, Session};
 
     pub(crate) fn user_id() -> &'static UserId {
         user_id!("@example:localhost")
     }
 
+    pub(crate) fn invited_user_id() -> &'static UserId {
+        user_id!("@invited:localhost")
+    }
+
     pub(crate) fn room_id() -> &'static RoomId {
         room_id!("!test:localhost")
     }
 
+    pub(crate) fn stripped_room_id() -> &'static RoomId {
+        room_id!("!stripped:localhost")
+    }
+
     pub(crate) fn first_receipt_event_id() -> &'static EventId {
         event_id!("$example")
     }
 
     pub(crate) fn second_receipt_event_id() -> &'static EventId {
         event_id!("$other")
     }
+
+    /// Populate the given `StateStore`.
+    pub(crate) async fn populated_store(inner: Box<dyn StateStore>) -> Result<Store> {
+        let mut changes = StateChanges::default();
+        let store = Store::new(inner);
+
+        let user_id = user_id();
+        let invited_user_id = invited_user_id();
+        let room_id = room_id();
+        let stripped_room_id = stripped_room_id();
+        let device_id = device_id!("device");
+
+        let session = Session {
+            access_token: "token".to_string(),
+            user_id: user_id.to_owned(),
+            device_id: device_id.to_owned(),
+        };
+        store.restore_session(session).await.unwrap();
+
+        changes.sync_token = Some("t392-516_47314_0_7_1_1_1_11444_1".to_string());
+
+        let presence_json: &JsonValue = &test_json::PRESENCE;
+        let presence_raw =
+            serde_json::from_value::<Raw<PresenceEvent>>(presence_json.clone()).unwrap();
+        let presence_event = presence_raw.deserialize().unwrap();
+        changes.add_presence_event(presence_event, presence_raw);
+
+        let pushrules_json: &JsonValue = &test_json::PUSH_RULES;
+        let pushrules_raw =
+            serde_json::from_value::<Raw<AnyGlobalAccountDataEvent>>(pushrules_json.clone())
+                .unwrap();
+        let pushrules_event = pushrules_raw.deserialize().unwrap();
+        changes.add_account_data(pushrules_event, pushrules_raw);
+
+        let mut room = store.get_or_create_room(room_id, RoomType::Joined).await.clone_info();
+        room.mark_as_left();
+
+        let tag_json: &JsonValue = &test_json::TAG;
+        let tag_raw =
+            serde_json::from_value::<Raw<AnyRoomAccountDataEvent>>(tag_json.clone()).unwrap();
+        let tag_event = tag_raw.deserialize().unwrap();
+        changes.add_room_account_data(room_id, tag_event, tag_raw);
+
+        let name_json: &JsonValue = &test_json::NAME;
+        let name_raw = serde_json::from_value::<Raw<AnySyncStateEvent>>(name_json.clone()).unwrap();
+        let name_event = name_raw.deserialize().unwrap();
+        room.handle_state_event(&name_event.content());
+        changes.add_state_event(room_id, name_event, name_raw);
+
+        let topic_json: &JsonValue = &test_json::TOPIC;
+        let topic_raw =
+            serde_json::from_value::<Raw<AnySyncStateEvent>>(topic_json.clone()).unwrap();
+        let topic_event = topic_raw.deserialize().unwrap();
+        room.handle_state_event(&topic_event.content());
+        changes.add_state_event(room_id, topic_event, topic_raw);
+
+        let mut room_ambiguity_map = BTreeMap::new();
+        let mut room_profiles = BTreeMap::new();
+        let mut room_members = BTreeMap::new();
+
+        let member_json: &JsonValue = &test_json::MEMBER;
+        let member_event = serde_json::from_value::<MemberEvent>(member_json.clone()).unwrap();
+        let member_event_content = member_event.content.clone();
+        room_ambiguity_map.insert(
+            member_event_content.displayname.clone().unwrap(),
+            BTreeSet::from([user_id.to_owned()]),
+        );
+        room_profiles.insert(user_id.to_owned(), member_event.content.clone());
+        room_members.insert(user_id.to_owned(), member_event);
+
+        let member_state_raw =
+            serde_json::from_value::<Raw<AnySyncStateEvent>>(member_json.clone()).unwrap();
+        let member_state_event = member_state_raw.deserialize().unwrap();
+        changes.add_state_event(room_id, member_state_event, member_state_raw);
+
+        let invited_member_json: &JsonValue = &test_json::MEMBER_INVITE;
+        let invited_member_event =
+            serde_json::from_value::<MemberEvent>(invited_member_json.clone()).unwrap();
+        room_ambiguity_map
+            .entry(member_event_content.displayname.clone().unwrap())
+            .or_default()
+            .insert(invited_user_id.to_owned());
+        room_profiles.insert(invited_user_id.to_owned(), invited_member_event.content.clone());
+        room_members.insert(invited_user_id.to_owned(), invited_member_event);
+
+        let invited_member_state_raw =
+            serde_json::from_value::<Raw<AnySyncStateEvent>>(invited_member_json.clone()).unwrap();
+        let invited_member_state_event = invited_member_state_raw.deserialize().unwrap();
+        changes.add_state_event(room_id, invited_member_state_event, invited_member_state_raw);
+
+        let receipt_json: &JsonValue = &test_json::READ_RECEIPT;
+        let receipt_event =
+            serde_json::from_value::<AnySyncEphemeralRoomEvent>(receipt_json.clone()).unwrap();
+        let receipt_content = match receipt_event.content() {
+            AnyEphemeralRoomEventContent::Receipt(content) => content,
+            _ => panic!(),
+        };
+        changes.add_receipts(room_id, receipt_content);
+
+        changes.ambiguity_maps.insert(room_id.to_owned(), room_ambiguity_map);
+        changes.profiles.insert(room_id.to_owned(), room_profiles);
+        changes.members.insert(room_id.to_owned(), room_members);
+        changes.add_room(room);
+
+        let mut stripped_room =
+            store.get_or_create_stripped_room(stripped_room_id).await.clone_info();
+
+        let stripped_name_json: &JsonValue = &test_json::NAME_STRIPPED;
+        let stripped_name_raw =
+            serde_json::from_value::<Raw<AnyStrippedStateEvent>>(stripped_name_json.clone())
+                .unwrap();
+        let stripped_name_event = stripped_name_raw.deserialize().unwrap();
+        stripped_room.handle_state_event(&stripped_name_event.content());
+        changes.stripped_state.insert(
+            stripped_room_id.to_owned(),
+            BTreeMap::from([(
+                stripped_name_event.content().event_type().to_owned(),
+                BTreeMap::from([(
+                    stripped_name_event.state_key().to_owned(),
+                    stripped_name_raw.clone(),
+                )]),
+            )]),
+        );
+        changes.invited_room_info.insert(stripped_room_id.to_owned(), stripped_room.clone());
+        changes.add_stripped_room(stripped_room);
+
+        let stripped_member_json: &JsonValue = &test_json::MEMBER_STRIPPED;
+        let stripped_member_event =
+            serde_json::from_value::<StrippedMemberEvent>(stripped_member_json.clone()).unwrap();
+        changes.add_stripped_member(stripped_room_id, stripped_member_event);
+
+        store.save_changes(&changes).await?;
+        Ok(store)
+    }
 }

crates/matrix-sdk-base/src/store/sled_store/mod.rs

@@ -1127,7 +1127,9 @@ mod test {
     use crate::{
         deserialized_responses::MemberEvent,
         media::{MediaFormat, MediaRequest, MediaThumbnailSize, MediaType},
-        store::test::{first_receipt_event_id, room_id, second_receipt_event_id, user_id},
+        store::test::{
+            first_receipt_event_id, populated_store, room_id, second_receipt_event_id, user_id,
+        },
         StateStore,
     };
 
@@ -1323,4 +1325,45 @@ mod test {
 
         Ok(())
     }
+
+    #[async_test]
+    async fn test_populate_store() {
+        let room_id = room_id();
+        let user_id = user_id();
+
+        let store = populated_store(Box::new(SledStore::open().unwrap())).await.unwrap();
+
+        assert!(store.get_sync_token().await.unwrap().is_some());
+        assert!(store.get_presence_event(user_id).await.unwrap().is_some());
+        assert_eq!(store.get_room_infos().await.unwrap().len(), 2);
+        assert_eq!(store.get_stripped_room_infos().await.unwrap().len(), 1);
+        assert!(store.get_account_data_event(EventType::PushRules).await.unwrap().is_some());
+
+        assert!(store.get_state_event(room_id, EventType::RoomName, "").await.unwrap().is_some());
+        assert_eq!(store.get_state_events(room_id, EventType::RoomTopic).await.unwrap().len(), 1);
+        assert!(store.get_profile(room_id, user_id).await.unwrap().is_some());
+        assert!(store.get_member_event(room_id, user_id).await.unwrap().is_some());
+        assert_eq!(store.get_user_ids(room_id).await.unwrap().len(), 2);
+        assert_eq!(store.get_invited_user_ids(room_id).await.unwrap().len(), 1);
+        assert_eq!(store.get_joined_user_ids(room_id).await.unwrap().len(), 1);
+        assert_eq!(store.get_users_with_display_name(room_id, "example").await.unwrap().len(), 2);
+        assert!(store
+            .get_room_account_data_event(room_id, EventType::Tag)
+            .await
+            .unwrap()
+            .is_some());
+        assert!(store
+            .get_user_room_receipt_event(room_id, ReceiptType::Read, user_id)
+            .await
+            .unwrap()
+            .is_some());
+        assert_eq!(
+            store
+                .get_event_room_receipt_events(room_id, ReceiptType::Read, first_receipt_event_id())
+                .await
+                .unwrap()
+                .len(),
+            1
+        );
+    }
 }

crates/matrix-sdk-test/src/lib.rs

@@ -26,12 +26,14 @@ pub enum EventsJson {
     HistoryVisibility,
     JoinRules,
     Member,
+    MemberInvite,
     MemberNameChange,
     MessageEmote,
     MessageNotice,
     MessageText,
     Name,
     PowerLevels,
+    PushRules,
     Presence,
     ReadReceipt,
     ReadReceiptOther,
@@ -122,9 +124,10 @@ impl EventBuilder {
     }
 
     /// Add an event to the room events `Vec`.
-    #[allow(clippy::match_single_binding, unused)]
+    #[allow(unused)]
     pub fn add_account(&mut self, json: EventsJson) -> &mut Self {
         let val: &JsonValue = match json {
+            EventsJson::PushRules => &test_json::PUSH_RULES,
             _ => panic!("unknown account event {:?}", json),
         };
 
@@ -137,6 +140,7 @@ impl EventBuilder {
     pub fn add_room_event(&mut self, json: EventsJson) -> &mut Self {
         let val: &JsonValue = match json {
             EventsJson::Member => &test_json::MEMBER,
+            EventsJson::MemberInvite => &test_json::MEMBER_INVITE,
             EventsJson::MemberNameChange => &test_json::MEMBER_NAME_CHANGE,
             EventsJson::PowerLevels => &test_json::POWER_LEVELS,
             _ => panic!("unknown room event json {:?}", json),