refactor(tests): make use of MatrixMockServer in timeline/pinned_event

crates/matrix-sdk-ui/tests/integration/timeline/pinned_event.rs

@@ -5,18 +5,14 @@ use eyeball_im::VectorDiff;
 use futures_util::StreamExt as _;
 use matrix_sdk::{
     Client, Room, assert_let_timeout,
-    config::SyncSettings,
-    test_utils::{
-        logged_in_client_with_server,
-        mocks::{MatrixMockServer, RoomMessagesResponseTemplate, RoomRelationsResponseTemplate},
+    test_utils::mocks::{
+        MatrixMockServer, RoomMessagesResponseTemplate, RoomRelationsResponseTemplate,
     },
     timeout::timeout,
 };
 use matrix_sdk_base::deserialized_responses::TimelineEvent;
 use matrix_sdk_common::executor::spawn;
-use matrix_sdk_test::{
-    BOB, JoinedRoomBuilder, SyncResponseBuilder, async_test, event_factory::EventFactory,
-};
+use matrix_sdk_test::{BOB, JoinedRoomBuilder, async_test, event_factory::EventFactory};
 use matrix_sdk_ui::timeline::{RoomExt, TimelineBuilder, TimelineFocus};
 use ruma::{
     EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, RoomId, UserId, assign,
@@ -36,12 +32,7 @@ use ruma::{
 };
 use stream_assert::assert_pending;
 use tokio::time::sleep;
-use wiremock::{
-    Mock, ResponseTemplate,
-    matchers::{header, method, path_regex},
-};
-
-use crate::mock_sync;
+use wiremock::ResponseTemplate;
 
 #[async_test]
 async fn test_new_pinned_events_are_not_added_on_sync() {
@@ -860,7 +851,8 @@ async fn test_redacted_events_are_reflected_in_sync() {
 
 #[async_test]
 async fn test_ensure_max_concurrency_is_observed() {
-    let (client, server) = logged_in_client_with_server().await;
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
     let room_id = owned_room_id!("!a_room:example.org");
 
     let pinned_event_ids: Vec<OwnedEventId> =
@@ -881,27 +873,19 @@ async fn test_ensure_max_concurrency_is_observed() {
 
     let pinned_event =
         EventFactory::new().room(&room_id).sender(*BOB).text_msg("A message").into_raw_timeline();
-    Mock::given(method("GET"))
-        .and(path_regex(r"/_matrix/client/r0/rooms/.*/event/.*"))
-        .and(header("authorization", "Bearer 1234"))
-        .respond_with(
+    server
+        .mock_room_event()
+        .ok_with_template(
             ResponseTemplate::new(200)
                 .set_delay(Duration::from_secs(60))
                 .set_body_json(pinned_event.json()),
         )
         // Verify this endpoint is only called the max concurrent amount of times.
         .expect(max_concurrent_requests as u64)
-        .mount(&server)
+        .mount()
         .await;
 
-    let mut sync_response_builder = SyncResponseBuilder::new();
-    let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
-    let json_response =
-        sync_response_builder.add_joined_room(joined_room_builder).build_json_sync_response();
-    mock_sync(&server, json_response, None).await;
-    let _ = client.sync_once(sync_settings.clone()).await;
-
-    let room = client.get_room(&room_id).unwrap();
+    let room = server.sync_room(&client, joined_room_builder).await;
 
     // Start loading the pinned event timeline asynchronously.
     let handle = spawn({
@@ -920,7 +904,7 @@ async fn test_ensure_max_concurrency_is_observed() {
 
     // The real check happens here, based on the `max_concurrent_requests` expected
     // value set above for the mock endpoint.
-    server.verify().await;
+    server.server().verify().await;
 }
 
 async fn mock_events_endpoint(

crates/matrix-sdk/src/test_utils/mocks/mod.rs

@@ -2937,6 +2937,19 @@ impl<'a> MockEndpoint<'a, RoomEventEndpoint> {
             .respond_with(ResponseTemplate::new(200).set_body_json(event.into_raw().json()));
         MatrixMock { server: self.server, mock }
     }
+
+    /// Returns a room event endpoint mock with a custom [`ResponseTemplate`].
+    ///
+    /// The path restriction is applied automatically. This is useful when you
+    /// need to configure specific response properties like delays.
+    pub fn ok_with_template(self, template: ResponseTemplate) -> MatrixMock<'a> {
+        let room_path = self.endpoint.room.map_or_else(|| ".*".to_owned(), |room| room.to_string());
+        let mock = self
+            .mock
+            .and(path_regex(format!(r"^/_matrix/client/v3/rooms/{room_path}/event/")))
+            .respond_with(template);
+        MatrixMock { server: self.server, mock }
+    }
 }
 
 /// A builder pattern for the response to a [`RoomEventContextEndpoint`]