diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/all.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/all.rs
index 0d8f61769..282aa60ee 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/all.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/all.rs
@@ -24,7 +24,7 @@ pub fn new_filter(filters: Vec<BoxedFilterFn>) -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -32,7 +32,8 @@ mod tests {
 
     #[async_test]
     async fn test_one_filter() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         {
@@ -52,7 +53,8 @@ mod tests {
 
     #[async_test]
     async fn test_two_filters() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         {
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/any.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/any.rs
index af3d40929..b27501502 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/any.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/any.rs
@@ -24,7 +24,7 @@ pub fn new_filter(filters: Vec<BoxedFilterFn>) -> impl Filter + use<> {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -32,7 +32,8 @@ mod tests {
 
     #[async_test]
     async fn test_one_filter_is_true() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter = |_: &_| true;
@@ -43,7 +44,8 @@ mod tests {
 
     #[async_test]
     async fn test_one_filter_is_false() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter = |_: &_| false;
@@ -54,7 +56,8 @@ mod tests {
 
     #[async_test]
     async fn test_two_filters_with_true_true() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter1 = |_: &_| true;
@@ -66,7 +69,8 @@ mod tests {
 
     #[async_test]
     async fn test_two_filters_with_true_false() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter1 = |_: &_| true;
@@ -78,7 +82,8 @@ mod tests {
 
     #[async_test]
     async fn test_two_filters_with_false_true() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter1 = |_: &_| false;
@@ -90,7 +95,8 @@ mod tests {
 
     #[async_test]
     async fn test_two_filters_with_false_false() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter1 = |_: &_| false;
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/category.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/category.rs
index cab1db365..fcff66623 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/category.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/category.rs
@@ -68,7 +68,7 @@ pub fn new_filter(expected_category: RoomCategory) -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -76,7 +76,8 @@ mod tests {
 
     #[async_test]
     async fn test_kind_is_group() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let number_of_direct_targets = |_room: &RoomListItem| Some(42);
@@ -98,7 +99,8 @@ mod tests {
 
     #[async_test]
     async fn test_kind_is_people() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let number_of_direct_targets = |_room: &RoomListItem| Some(1);
@@ -120,7 +122,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_kind_cannot_be_found() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let number_of_direct_targets = |_room: &RoomListItem| None;
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/deduplicate_versions.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/deduplicate_versions.rs
index c6c38de84..10c80440a 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/deduplicate_versions.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/deduplicate_versions.rs
@@ -82,7 +82,7 @@ pub fn new_filter() -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_base::RoomState;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
@@ -91,7 +91,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_room: &RoomListItem| (RoomState::Joined, None), &room));
@@ -99,7 +100,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_joined() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Joined, Some(SuccessorRoomState::Joined)), &room).not());
@@ -107,7 +109,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_left() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Joined, Some(SuccessorRoomState::Left)), &room).not());
@@ -115,7 +118,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_banned() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Joined, Some(SuccessorRoomState::Banned)), &room).not());
@@ -123,7 +127,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_invited() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Joined, Some(SuccessorRoomState::Invited)), &room));
@@ -131,7 +136,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_joined_and_room_b_is_knocked() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Joined, Some(SuccessorRoomState::Knocked)), &room));
@@ -139,7 +145,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_left_and_room_b_is_joined() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Left, Some(RoomState::Joined)), &room).not());
@@ -147,7 +154,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_invited_and_room_b_is_joined() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Invited, Some(RoomState::Joined)), &room).not());
@@ -155,7 +163,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_banned_and_room_b_is_joined() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Banned, Some(RoomState::Joined)), &room).not());
@@ -163,7 +172,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_knocked_and_room_b_is_joined() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| (RoomState::Knocked, Some(RoomState::Joined)), &room).not());
@@ -171,7 +181,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_left_and_room_b_is_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let state = |_: &RoomListItem| (RoomState::Left, None);
@@ -180,7 +191,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_invited_and_room_b_is_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let state = |_: &RoomListItem| (RoomState::Invited, None);
@@ -189,7 +201,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_banned_and_room_b_is_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let state = |_: &RoomListItem| (RoomState::Banned, None);
@@ -198,7 +211,8 @@ mod tests {
 
     #[async_test]
     async fn test_room_a_is_knocked_and_room_b_is_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let state = |_: &RoomListItem| (RoomState::Knocked, None);
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/favourite.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/favourite.rs
index ac09d83de..663ea5db7 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/favourite.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/favourite.rs
@@ -31,7 +31,7 @@ pub fn new_filter() -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -39,7 +39,8 @@ mod tests {
 
     #[async_test]
     async fn test_is_favourite() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_: &RoomListItem| true, &room));
@@ -47,7 +48,8 @@ mod tests {
 
     #[async_test]
     async fn test_is_not_favourite() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_: &RoomListItem| false, &room).not());
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/identifiers.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/identifiers.rs
index 5c4dc38f5..41a85d6fc 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/identifiers.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/identifiers.rs
@@ -24,7 +24,7 @@ pub fn new_filter(identifiers: Vec<OwnedRoomId>) -> impl Filter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::{owned_room_id, room_id};
 
@@ -32,7 +32,8 @@ mod tests {
 
     #[async_test]
     async fn test_space() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let rooms = new_rooms(
             [room_id!("!alpha:b.c"), room_id!("!beta:b.c"), room_id!("!gamma:b.c")],
             &client,
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/invite.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/invite.rs
index c40879c06..547a181ce 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/invite.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/invite.rs
@@ -33,7 +33,7 @@ pub fn new_filter() -> impl Filter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_base::RoomState;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
@@ -42,7 +42,8 @@ mod tests {
 
     #[async_test]
     async fn test_all_invite_kind() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         // When a room has been left, it doesn't match.
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/joined.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/joined.rs
index e58beba88..a432697e4 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/joined.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/joined.rs
@@ -33,7 +33,7 @@ pub fn new_filter() -> impl Filter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_base::RoomState;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
@@ -42,7 +42,8 @@ mod tests {
 
     #[async_test]
     async fn test_all_joined_kind() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         // When a room has been left, it doesn't match.
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/low_priority.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/low_priority.rs
index a95de2b46..701300610 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/low_priority.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/low_priority.rs
@@ -33,7 +33,7 @@ pub fn new_filter() -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -41,7 +41,8 @@ mod tests {
 
     #[async_test]
     async fn test_is_low_priority() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| true, &room));
@@ -49,7 +50,8 @@ mod tests {
 
     #[async_test]
     async fn test_is_not_low_priority() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(matches(|_| false, &room).not());
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/mod.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/mod.rs
index ea9ccf16d..9c4274fb0 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/mod.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/mod.rs
@@ -79,9 +79,9 @@ pub use invite::new_filter as new_filter_invite;
 pub use joined::new_filter as new_filter_joined;
 pub use low_priority::new_filter as new_filter_low_priority;
 #[cfg(test)]
-use matrix_sdk::Client;
+use matrix_sdk::{Client, test_utils::mocks::MatrixMockServer};
 #[cfg(test)]
-use matrix_sdk_test::{JoinedRoomBuilder, SyncResponseBuilder};
+use matrix_sdk_test::JoinedRoomBuilder;
 pub use non_left::new_filter as new_filter_non_left;
 pub use none::new_filter as new_filter_none;
 pub use normalized_match_room_name::new_filter as new_filter_normalized_match_room_name;
@@ -91,11 +91,6 @@ use ruma::RoomId;
 pub use space::new_filter as new_filter_space;
 use unicode_normalization::{UnicodeNormalization, char::is_combining_mark};
 pub use unread::new_filter as new_filter_unread;
-#[cfg(test)]
-use wiremock::{
-    Mock, MockServer, ResponseTemplate,
-    matchers::{header, method, path},
-};
 
 use super::RoomListItem;
 
@@ -123,25 +118,17 @@ fn normalize_string(str: &str) -> String {
 pub(super) async fn new_rooms<const N: usize>(
     room_ids: [&RoomId; N],
     client: &Client,
-    server: &MockServer,
+    server: &MatrixMockServer,
 ) -> [RoomListItem; N] {
-    let mut response_builder = SyncResponseBuilder::default();
-
-    for room_id in room_ids {
-        response_builder.add_joined_room(JoinedRoomBuilder::new(room_id));
-    }
-
-    let json_response = response_builder.build_json_sync_response();
-
-    let _scope = Mock::given(method("GET"))
-        .and(path("/_matrix/client/r0/sync"))
-        .and(header("authorization", "Bearer 1234"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json_response))
-        .mount_as_scoped(server)
+    server
+        .mock_sync()
+        .ok_and_run(client, |builder| {
+            for room_id in room_ids {
+                builder.add_joined_room(JoinedRoomBuilder::new(room_id));
+            }
+        })
         .await;
 
-    let _response = client.sync_once(Default::default()).await.unwrap();
-
     room_ids.map(|room_id| client.get_room(room_id).unwrap().into())
 }
 
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/non_left.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/non_left.rs
index f9966330d..e7cfc3f1f 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/non_left.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/non_left.rs
@@ -35,7 +35,7 @@ pub fn new_filter() -> impl Filter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_base::RoomState;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
@@ -44,7 +44,8 @@ mod tests {
 
     #[async_test]
     async fn test_all_non_left_kind_of_room_list_entry() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         // When a room has been left, it doesn't match.
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/none.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/none.rs
index e409462f9..9f35643eb 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/none.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/none.rs
@@ -23,7 +23,7 @@ pub fn new_filter() -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -31,7 +31,8 @@ mod tests {
 
     #[async_test]
     async fn test_all_kind_of_room_list_entry() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let none = new_filter();
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/not.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/not.rs
index 9d70c1254..b6db51922 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/not.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/not.rs
@@ -26,7 +26,7 @@ pub fn new_filter(filter: BoxedFilterFn) -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -34,7 +34,8 @@ mod tests {
 
     #[async_test]
     async fn test_true() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter = Box::new(|_: &_| true);
@@ -45,7 +46,8 @@ mod tests {
 
     #[async_test]
     async fn test_false() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let filter = Box::new(|_: &_| false);
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/space.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/space.rs
index 43eb778a5..c57d68475 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/space.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/space.rs
@@ -31,7 +31,7 @@ pub fn new_filter() -> impl Filter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -39,7 +39,8 @@ mod tests {
 
     #[async_test]
     async fn test_space() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         assert!(!matches(|_| false, &room));
diff --git a/crates/matrix-sdk-ui/src/room_list_service/filters/unread.rs b/crates/matrix-sdk-ui/src/room_list_service/filters/unread.rs
index 4d3b353cb..40b0c88b7 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/filters/unread.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/filters/unread.rs
@@ -40,7 +40,7 @@ pub fn new_filter() -> impl Filter {
 mod tests {
     use std::ops::Not;
 
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_base::read_receipts::RoomReadReceipts;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
@@ -49,7 +49,8 @@ mod tests {
 
     #[async_test]
     async fn test_has_unread_notifications() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         for is_marked_as_unread in [true, false] {
@@ -69,7 +70,8 @@ mod tests {
 
     #[async_test]
     async fn test_has_unread_messages_but_no_unread_notifications_and_is_not_marked_as_unread() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let read_receipts_and_unread = |_: &RoomListItem| {
@@ -84,7 +86,8 @@ mod tests {
 
     #[async_test]
     async fn test_has_unread_messages_but_no_unread_notifications_and_is_marked_as_unread() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let read_receipts_and_unread = |_: &RoomListItem| {
@@ -99,7 +102,8 @@ mod tests {
 
     #[async_test]
     async fn test_has_no_unread_notifications_and_is_not_marked_as_unread() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let read_receipts_and_unread = |_: &RoomListItem| (RoomReadReceipts::default(), false);
@@ -109,7 +113,8 @@ mod tests {
 
     #[async_test]
     async fn test_has_no_unread_notifications_and_is_marked_as_unread() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room] = new_rooms([room_id!("!a:b.c")], &client, &server).await;
 
         let read_receipts_and_unread = |_: &RoomListItem| (RoomReadReceipts::default(), true);
diff --git a/crates/matrix-sdk-ui/src/room_list_service/sorters/latest_event.rs b/crates/matrix-sdk-ui/src/room_list_service/sorters/latest_event.rs
index 208f68547..52103f5cf 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/sorters/latest_event.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/sorters/latest_event.rs
@@ -68,7 +68,7 @@ mod tests {
     use matrix_sdk::{
         latest_events::{LatestEventValue, LocalLatestEventValue, RemoteLatestEventValue},
         store::SerializableEventContent,
-        test_utils::logged_in_client_with_server,
+        test_utils::mocks::MatrixMockServer,
     };
     use matrix_sdk_test::async_test;
     use ruma::{
@@ -142,7 +142,8 @@ mod tests {
 
     #[async_test]
     async fn test_none_or_remote_and_none_or_remote() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
 
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
@@ -170,7 +171,8 @@ mod tests {
 
     #[async_test]
     async fn test_none_or_remote_and_local() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
 
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
@@ -210,7 +212,8 @@ mod tests {
 
     #[async_test]
     async fn test_local_and_none_or_remote() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
 
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
@@ -250,7 +253,8 @@ mod tests {
 
     #[async_test]
     async fn test_local_and_local() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
 
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
diff --git a/crates/matrix-sdk-ui/src/room_list_service/sorters/lexicographic.rs b/crates/matrix-sdk-ui/src/room_list_service/sorters/lexicographic.rs
index 80f6c10f9..68c6b6d37 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/sorters/lexicographic.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/sorters/lexicographic.rs
@@ -37,7 +37,7 @@ pub fn new_sorter(sorters: Vec<BoxedSorterFn>) -> impl Sorter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -45,7 +45,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_zero_sorter() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -56,7 +57,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_one_sorter() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -68,7 +70,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_two_sorters() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -81,7 +84,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_more_sorters() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
diff --git a/crates/matrix-sdk-ui/src/room_list_service/sorters/name.rs b/crates/matrix-sdk-ui/src/room_list_service/sorters/name.rs
index 3cef2670d..b89fd8ccb 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/sorters/name.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/sorters/name.rs
@@ -41,7 +41,7 @@ pub fn new_sorter() -> impl Sorter {
 
 #[cfg(test)]
 mod tests {
-    use matrix_sdk::test_utils::logged_in_client_with_server;
+    use matrix_sdk::test_utils::mocks::MatrixMockServer;
     use matrix_sdk_test::async_test;
     use ruma::room_id;
 
@@ -49,7 +49,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_two_names() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -80,7 +81,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_one_name() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -100,7 +102,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_zero_name() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
diff --git a/crates/matrix-sdk-ui/src/room_list_service/sorters/recency.rs b/crates/matrix-sdk-ui/src/room_list_service/sorters/recency.rs
index 21076697f..2db1003d9 100644
--- a/crates/matrix-sdk-ui/src/room_list_service/sorters/recency.rs
+++ b/crates/matrix-sdk-ui/src/room_list_service/sorters/recency.rs
@@ -107,7 +107,7 @@ mod tests {
         RoomRecencyStamp,
         latest_events::{LatestEventValue, LocalLatestEventValue, RemoteLatestEventValue},
         store::SerializableEventContent,
-        test_utils::logged_in_client_with_server,
+        test_utils::mocks::MatrixMockServer,
     };
     use matrix_sdk_base::RoomInfoNotableUpdateReasons;
     use matrix_sdk_test::async_test;
@@ -179,7 +179,8 @@ mod tests {
 
     #[async_test]
     async fn test_extract_scores_with_none() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [mut room_a, mut room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -219,7 +220,8 @@ mod tests {
 
     #[async_test]
     async fn test_extract_scores_with_remote_or_local() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [mut room_a, mut room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -245,7 +247,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_two_scores() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -274,7 +277,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_one_score() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;
 
@@ -293,7 +297,8 @@ mod tests {
 
     #[async_test]
     async fn test_with_zero_score() {
-        let (client, server) = logged_in_client_with_server().await;
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
         let [room_a, room_b] =
             new_rooms([room_id!("!a:b.c"), room_id!("!d:e.f")], &client, &server).await;