refactor: Fetch the ignored user list account data from the store for Client::is_user_ignored

Also move it to `BaseClient` instead.

Author: jmartinesp

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

@@ -36,18 +36,19 @@ use ruma::DeviceId;
 use ruma::{
     api::client::{self as api, sync::sync_events::v5},
     events::{
+        ignored_user_list::IgnoredUserListEventContent,
         push_rules::{PushRulesEvent, PushRulesEventContent},
         room::member::SyncRoomMemberEvent,
         StateEvent, StateEventType,
     },
     push::Ruleset,
     time::Instant,
-    OwnedRoomId, OwnedUserId, RoomId,
+    OwnedRoomId, OwnedUserId, RoomId, UserId,
 };
 use tokio::sync::{broadcast, Mutex};
 #[cfg(feature = "e2e-encryption")]
 use tokio::sync::{RwLock, RwLockReadGuard};
-use tracing::{debug, enabled, info, instrument, Level};
+use tracing::{debug, enabled, info, instrument, warn, Level};
 
 #[cfg(feature = "e2e-encryption")]
 use crate::RoomMemberships;
@@ -960,6 +961,27 @@ impl BaseClient {
     pub fn room_info_notable_update_receiver(&self) -> broadcast::Receiver<RoomInfoNotableUpdate> {
         self.room_info_notable_update_sender.subscribe()
     }
+
+    /// Checks whether the provided `user_id` belongs to an ignored user.
+    pub async fn is_user_ignored(&self, user_id: &UserId) -> bool {
+        match self.state_store.get_account_data_event_static::<IgnoredUserListEventContent>().await
+        {
+            Ok(Some(raw_ignored_user_list)) => match raw_ignored_user_list.deserialize() {
+                Ok(current_ignored_user_list) => {
+                    current_ignored_user_list.content.ignored_users.contains_key(user_id)
+                }
+                Err(error) => {
+                    warn!(?error, "Failed to deserialize the ignored user list event");
+                    false
+                }
+            },
+            Ok(None) => false,
+            Err(error) => {
+                warn!(?error, "Could not get the ignored user list from the state store");
+                false
+            }
+        }
+    }
 }
 
 /// Represent the `required_state` values sent by a sync request.
@@ -1597,4 +1619,27 @@ mod tests {
         assert_let!(Some(ignored) = subscriber.next().await);
         assert!(ignored.is_empty());
     }
+
+    #[async_test]
+    async fn test_is_user_ignored() {
+        let ignored_user_id = user_id!("@alice:example.org");
+        let client = logged_in_base_client(None).await;
+
+        let mut sync_builder = SyncResponseBuilder::new();
+        let response = sync_builder
+            .add_global_account_data_event(matrix_sdk_test::GlobalAccountDataTestEvent::Custom(
+                json!({
+                    "content": {
+                        "ignored_users": {
+                            ignored_user_id: {}
+                        }
+                    },
+                    "type": "m.ignored_user_list",
+                }),
+            ))
+            .build_sync_response();
+        client.receive_sync_response(response).await.unwrap();
+
+        assert!(client.is_user_ignored(ignored_user_id).await);
+    }
 }

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

@@ -693,7 +693,7 @@ impl NotificationClient {
                     match notification_result {
                         Ok(notification_status) => match notification_status {
                             NotificationStatus::Event(event) => {
-                                if self.client.is_user_ignored(event.event.sender()) {
+                                if self.client.is_user_ignored(event.event.sender()).await {
                                     result.add_notification(
                                         event_id,
                                         NotificationStatus::EventFilteredOut,
@@ -768,7 +768,7 @@ impl NotificationClient {
         )
         .await?;
 
-        if self.client.is_user_ignored(notification_item.event.sender()) {
+        if self.client.is_user_ignored(notification_item.event.sender()).await {
             Ok(None)
         } else {
             Ok(Some(notification_item))

crates/matrix-sdk-ui/tests/integration/notification_client.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::BTreeMap,
     sync::{Arc, Mutex},
     time::Duration,
 };
@@ -9,8 +10,8 @@ use matrix_sdk::{
     test_utils::{logged_in_client_with_server, mocks::MatrixMockServer},
 };
 use matrix_sdk_test::{
-    async_test, mocks::mock_encryption_state, JoinedRoomBuilder, StateTestEvent,
-    SyncResponseBuilder,
+    async_test, event_factory::EventFactory, mocks::mock_encryption_state, JoinedRoomBuilder,
+    StateTestEvent, SyncResponseBuilder,
 };
 use matrix_sdk_ui::{
     notification_client::{
@@ -19,7 +20,11 @@ use matrix_sdk_ui::{
     },
     sync_service::SyncService,
 };
-use ruma::{event_id, events::TimelineEventType, room_id, user_id};
+use ruma::{
+    event_id,
+    events::{room::member::MembershipState, TimelineEventType},
+    room_id, user_id,
+};
 use serde_json::json;
 use wiremock::{
     matchers::{header, method, path},
@@ -1083,7 +1088,6 @@ async fn test_notification_client_sliding_sync_filters_out_events_from_ignored_u
     let room_id = room_id!("!a98sd12bjh:example.org");
     let room_name = "The Maltese Falcon";
     let sender_display_name = "John Mastodon";
-    let sender_avatar_url = "https://example.org/avatar.jpeg";
     let event_id = event_id!("$example_event_id");
 
     let raw_event = EventFactory::new()
@@ -1093,6 +1097,23 @@ async fn test_notification_client_sliding_sync_filters_out_events_from_ignored_u
         .event_id(event_id)
         .into_raw_sync();
 
+    let event_factory = EventFactory::new().room(room_id);
+
+    let sender_member_event = event_factory
+        .member(sender)
+        .display_name(sender_display_name)
+        .membership(MembershipState::Join)
+        .into_raw_sync();
+
+    let own_member_event = event_factory
+        .member(&my_user_id)
+        .display_name("My self")
+        .membership(MembershipState::Join)
+        .into_raw_sync();
+
+    let power_levels_event =
+        event_factory.sender(sender).power_levels(&mut BTreeMap::new()).into_raw_sync();
+
     let pos = Mutex::new(0);
     Mock::given(SlidingSyncMatcher)
         .respond_with(move |request: &Request| {
@@ -1111,75 +1132,13 @@ async fn test_notification_client_sliding_sync_filters_out_events_from_ignored_u
 
                         "required_state": [
                             // Sender's member information.
-                            {
-                                "content": {
-                                    "avatar_url": sender_avatar_url,
-                                    "displayname": sender_display_name,
-                                    "membership": "join"
-                                },
-                                "room_id": room_id,
-                                "event_id": "$151800140517rfvjc:example.org",
-                                "membership": "join",
-                                "origin_server_ts": 151800140,
-                                "sender": sender,
-                                "state_key": sender,
-                                "type": "m.room.member",
-                                "unsigned": {
-                                    "age": 2970366,
-                                }
-                            },
+                            sender_member_event,
 
                             // Own member information.
-                            {
-                                "content": {
-                                    "avatar_url": null,
-                                    "displayname": "My Self",
-                                    "membership": "join"
-                                },
-                                "room_id": room_id,
-                                "event_id": "$151800140517rflkc:example.org",
-                                "membership": "join",
-                                "origin_server_ts": 151800140,
-                                "sender": my_user_id.clone(),
-                                "state_key": my_user_id,
-                                "type": "m.room.member",
-                                "unsigned": {
-                                    "age": 2970366,
-                                }
-                            },
+                            own_member_event,
 
                             // Power levels.
-                            {
-                                "content": {
-                                    "ban": 50,
-                                    "events": {
-                                        "m.room.avatar": 50,
-                                        "m.room.canonical_alias": 50,
-                                        "m.room.history_visibility": 100,
-                                        "m.room.name": 50,
-                                        "m.room.power_levels": 100,
-                                        "m.room.message": 25,
-                                    },
-                                    "events_default": 0,
-                                    "invite": 0,
-                                    "kick": 50,
-                                    "redact": 50,
-                                    "state_default": 50,
-                                    "users": {
-                                        "@example:localhost": 100,
-                                        sender: 0,
-                                    },
-                                    "users_default": 0,
-                                },
-                                "event_id": "$15139375512JaHAW:localhost",
-                                "origin_server_ts": 151393755,
-                                "sender": "@example:localhost",
-                                "state_key": "",
-                                "type": "m.room.power_levels",
-                                "unsigned": {
-                                    "age": 703422,
-                                },
-                            },
+                            power_levels_event,
                         ],
 
                         "timeline": [

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

@@ -2543,10 +2543,8 @@ impl Client {
     }
 
     /// Checks whether the provided `user_id` belongs to an ignored user.
-    pub fn is_user_ignored(&self, user_id: &UserId) -> bool {
-        let raw_user_id = user_id.to_string();
-        let current_ignored_user_list = self.subscribe_to_ignore_user_list_changes().get();
-        current_ignored_user_list.contains(&raw_user_id)
+    pub async fn is_user_ignored(&self, user_id: &UserId) -> bool {
+        self.base_client().is_user_ignored(user_id).await
     }
 }
 
@@ -2615,7 +2613,7 @@ pub(crate) mod tests {
             ignored_user_list::IgnoredUserListEventContent,
             media_preview_config::{InviteAvatars, MediaPreviewConfigEventContent, MediaPreviews},
         },
-        owned_room_id, room_alias_id, room_id, user_id, RoomId, ServerName, UserId,
+        owned_room_id, room_alias_id, room_id, RoomId, ServerName, UserId,
     };
     use serde_json::json;
     use stream_assert::{assert_next_matches, assert_pending};
@@ -3452,25 +3450,4 @@ pub(crate) mod tests {
         assert_eq!(initial_value.invite_avatars, InviteAvatars::On);
         assert_eq!(initial_value.media_previews, MediaPreviews::On);
     }
-
-    #[async_test]
-    async fn test_is_user_ignored() {
-        let server = MatrixMockServer::new().await;
-        let client = server.client_builder().build().await;
-
-        let user_id = user_id!("@alice:host");
-        assert!(!client.is_user_ignored(user_id));
-
-        server
-            .mock_sync()
-            .ok_and_run(&client, |builder| {
-                builder.add_global_account_data_event(GlobalAccountDataTestEvent::Custom(json!({
-                    "type": "m.ignored_user_list",
-                    "content": IgnoredUserListEventContent::users([user_id.to_owned()])
-                })));
-            })
-            .await;
-
-        assert!(client.is_user_ignored(user_id));
-    }
 }