feat(ui): RoomList::entries* manipulates a Room.

This patch is quite big… `RoomList::entries*` now returns `Room`s
instead of `RoomListEntry`s. This patch consequently updates all the
filters to manipulate `Room` instead of `RoomListEntry`. No more
`Client` is needed in the filters.

This patch also disables the `RoomList` integration test suite in order
to keep this patch “small”.

crates/matrix-sdk-ui/src/room_list_service/filters/all.rs

@@ -12,76 +12,80 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::{super::room_list::BoxedFilterFn, Filter};
+use super::{BoxedFilterFn, Filter};
 
 /// Create a new filter that will run multiple filters. It returns `false` if at
 /// least one of the filter returns `false`.
 pub fn new_filter(filters: Vec<BoxedFilterFn>) -> impl Filter {
-    move |room_list_entry| -> bool { filters.iter().all(|filter| filter(room_list_entry)) }
+    move |room| -> bool { filters.iter().all(|filter| filter(room)) }
 }
 
 #[cfg(test)]
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::RoomListEntry;
-    use ruma::room_id;
+    use matrix_sdk_test::async_test;
 
-    use super::new_filter;
+    use super::{
+        super::{client_and_server_prelude, new_room, Room},
+        *,
+    };
 
-    #[test]
-    fn test_one_filter() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_one_filter() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         {
             let filter = |_: &_| true;
             let all = new_filter(vec![Box::new(filter)]);
 
-            assert!(all(&room_list_entry));
+            assert!(all(&room));
         }
 
         {
             let filter = |_: &_| false;
             let all = new_filter(vec![Box::new(filter)]);
 
-            assert!(all(&room_list_entry).not());
+            assert!(all(&room).not());
         }
     }
 
-    #[test]
-    fn test_two_filters() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_two_filters() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         {
             let filter1 = |_: &_| true;
             let filter2 = |_: &_| true;
             let all = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-            assert!(all(&room_list_entry));
+            assert!(all(&room));
         }
 
         {
             let filter1 = |_: &_| true;
             let filter2 = |_: &_| false;
             let all = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-            assert!(all(&room_list_entry).not());
+            assert!(all(&room).not());
         }
 
         {
             let filter1 = |_: &_| false;
             let filter2 = |_: &_| true;
             let all = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-            assert!(all(&room_list_entry).not());
+            assert!(all(&room).not());
         }
 
         {
             let filter1 = |_: &_| false;
             let filter2 = |_: &_| false;
             let all = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-            assert!(all(&room_list_entry).not());
+            assert!(all(&room).not());
         }
     }
 }

crates/matrix-sdk-ui/src/room_list_service/filters/any.rs

@@ -12,84 +12,92 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use super::{super::room_list::BoxedFilterFn, Filter};
+use super::{BoxedFilterFn, Filter};
 
 /// Create a new filter that will run multiple filters. It returns `true` if at
 /// least one of the filter returns `true`.
 pub fn new_filter(filters: Vec<BoxedFilterFn>) -> impl Filter {
-    move |room_list_entry| -> bool { filters.iter().any(|filter| filter(room_list_entry)) }
+    move |room| -> bool { filters.iter().any(|filter| filter(room)) }
 }
 
 #[cfg(test)]
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::RoomListEntry;
-    use ruma::room_id;
+    use matrix_sdk_test::async_test;
 
-    use super::new_filter;
+    use super::{
+        super::{client_and_server_prelude, new_room},
+        *,
+    };
 
-    #[test]
-    fn test_one_filter_is_true() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_one_filter_is_true() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter = |_: &_| true;
         let any = new_filter(vec![Box::new(filter)]);
 
-        assert!(any(&room_list_entry));
+        assert!(any(&room));
     }
 
-    #[test]
-    fn test_one_filter_is_false() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_one_filter_is_false() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter = |_: &_| false;
         let any = new_filter(vec![Box::new(filter)]);
 
-        assert!(any(&room_list_entry).not());
+        assert!(any(&room).not());
     }
 
-    #[test]
-    fn test_two_filters_with_true_true() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_two_filters_with_true_true() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter1 = |_: &_| true;
         let filter2 = |_: &_| true;
         let any = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-        assert!(any(&room_list_entry));
+        assert!(any(&room));
     }
 
-    #[test]
-    fn test_two_filters_with_true_false() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_two_filters_with_true_false() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter1 = |_: &_| true;
         let filter2 = |_: &_| false;
         let any = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-        assert!(any(&room_list_entry));
+        assert!(any(&room));
     }
 
-    #[test]
-    fn test_two_filters_with_false_true() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_two_filters_with_false_true() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter1 = |_: &_| false;
         let filter2 = |_: &_| true;
         let any = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-        assert!(any(&room_list_entry));
+        assert!(any(&room));
     }
 
-    #[test]
-    fn test_two_filters_with_false_false() {
-        let room_list_entry = RoomListEntry::Filled(room_id!("!r0:bar.org").to_owned());
+    #[async_test]
+    async fn test_two_filters_with_false_false() {
+        let (client, server, sliding_sync) = client_and_server_prelude().await;
+        let room = new_room(&client, &server, &sliding_sync).await;
 
         let filter1 = |_: &_| false;
         let filter2 = |_: &_| false;
         let any = new_filter(vec![Box::new(filter1), Box::new(filter2)]);
 
-        assert!(any(&room_list_entry).not());
+        assert!(any(&room).not());
     }
 }