test: have the PendingEdit test helper use the matrix mock server and event cache storage

Author: bnjbvr

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

@@ -12,17 +12,24 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 
 use as_variant::as_variant;
 use assert_matches::assert_matches;
 use assert_matches2::assert_let;
 use eyeball_im::VectorDiff;
 use futures_util::{FutureExt, StreamExt};
 use matrix_sdk::{
-    config::SyncSettings, room::edit::EditedContent, test_utils::logged_in_client_with_server,
+    config::{StoreConfig, SyncSettings},
+    linked_chunk::{ChunkIdentifier, Update},
+    room::edit::EditedContent,
+    test_utils::{logged_in_client_with_server, mocks::MatrixMockServer},
     Client,
 };
+use matrix_sdk_base::event_cache::{
+    store::{EventCacheStore, MemoryStore},
+    Gap,
+};
 use matrix_sdk_test::{
     async_test, event_factory::EventFactory, mocks::mock_encryption_state, JoinedRoomBuilder,
     SyncResponseBuilder, ALICE, BOB,
@@ -46,7 +53,7 @@ use ruma::{
             MessageType, RoomMessageEventContent, RoomMessageEventContentWithoutRelation,
             TextMessageEventContent,
         },
-        AnyMessageLikeEventContent, AnyTimelineEvent,
+        AnyMessageLikeEventContent, AnyStateEvent, AnyTimelineEvent,
     },
     owned_event_id, room_id,
     serde::Raw,
@@ -57,7 +64,7 @@ use stream_assert::assert_next_matches;
 use tokio::{task::yield_now, time::sleep};
 use wiremock::{
     matchers::{header, method, path_regex},
-    Mock, MockServer, ResponseTemplate,
+    Mock, ResponseTemplate,
 };
 
 use crate::mock_sync;
@@ -851,69 +858,77 @@ async fn test_edit_local_echo_with_unsupported_content() {
 
 struct PendingEditHelper {
     client: Client,
-    server: MockServer,
+    server: MatrixMockServer,
     timeline: Timeline,
-    sync_builder: SyncResponseBuilder,
-    sync_settings: SyncSettings,
     room_id: OwnedRoomId,
 }
 
 impl PendingEditHelper {
     async fn new() -> Self {
         let room_id = room_id!("!a98sd12bjh:example.org");
-        let (client, server) = logged_in_client_with_server().await;
-        let sync_settings = SyncSettings::new().timeout(Duration::from_millis(3000));
-
-        let mut sync_builder = SyncResponseBuilder::new();
-        sync_builder.add_joined_room(JoinedRoomBuilder::new(room_id));
 
-        mock_sync(&server, sync_builder.build_json_sync_response(), None).await;
-        let _response = client.sync_once(sync_settings.clone()).await.unwrap();
-        server.reset().await;
+        let event_cache_store = Arc::new(MemoryStore::new());
+        let server = MatrixMockServer::new().await;
 
-        mock_encryption_state(&server, false).await;
+        let client = server
+            .client_builder()
+            .store_config(
+                StoreConfig::new("hodor".to_owned()).event_cache_store(event_cache_store.clone()),
+            )
+            .build()
+            .await;
 
         {
             // Fill the initial prev-batch token to avoid waiting for it later.
             let ec = client.event_cache();
             ec.subscribe().unwrap();
-            ec.add_initial_events(room_id, vec![], Some("prev-batch-token".to_owned()))
+            ec.enable_storage().unwrap();
+
+            event_cache_store
+                .handle_linked_chunk_updates(
+                    room_id,
+                    vec![
+                        // Maintain the invariant that the first chunk is an items.
+                        Update::NewItemsChunk {
+                            previous: None,
+                            new: ChunkIdentifier::new(0),
+                            next: None,
+                        },
+                        // Mind the gap!
+                        Update::NewGapChunk {
+                            previous: Some(ChunkIdentifier::new(0)),
+                            new: ChunkIdentifier::new(1),
+                            next: None,
+                            gap: Gap { prev_token: "prev-batch-token".to_owned() },
+                        },
+                    ],
+                )
                 .await
                 .unwrap();
         }
 
+        server.sync_joined_room(&client, room_id).await;
+        server.mock_room_state_encryption().plain().mount().await;
+
         let room = client.get_room(room_id).unwrap();
         let timeline = room.timeline().await.unwrap();
 
-        Self { client, server, timeline, sync_builder, sync_settings, room_id: room_id.to_owned() }
+        Self { client, server, timeline, room_id: room_id.to_owned() }
     }
 
     async fn handle_sync(&mut self, joined_room_builder: JoinedRoomBuilder) {
-        self.sync_builder.add_joined_room(joined_room_builder);
-
-        mock_sync(&self.server, self.sync_builder.build_json_sync_response(), None).await;
-        let _response = self.client.sync_once(self.sync_settings.clone()).await.unwrap();
-
-        self.server.reset().await;
+        self.server.sync_room(&self.client, joined_room_builder).await;
     }
 
     async fn handle_backpagination(&mut self, events: Vec<Raw<AnyTimelineEvent>>, batch_size: u16) {
-        Mock::given(method("GET"))
-            .and(path_regex(r"^/_matrix/client/r0/rooms/.*/messages$"))
-            .and(header("authorization", "Bearer 1234"))
-            .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-                "start": "123",
-                "end": "yolo",
-                "chunk": events,
-                "state": []
-            })))
-            .expect(1)
-            .mount(&self.server)
+        self.server
+            .mock_room_messages()
+            .ok("123".to_owned(), Some("yolo".to_owned()), events, Vec::<Raw<AnyStateEvent>>::new())
+            .mock_once()
+            .mount()
             .await;
 
         self.timeline.live_paginate_backwards(batch_size).await.unwrap();
-
-        self.server.reset().await;
     }
 }