test: add a mocks mod in matrix-sdk-test to reuse across different integration tests

Author: bnjbvr

Cargo.lock

@@ -23,8 +23,8 @@ use matrix_sdk::{
     test_utils::{events::EventFactory, logged_in_client_with_server},
 };
 use matrix_sdk_test::{
-    async_test, sync_timeline_event, JoinedRoomBuilder, RoomAccountDataTestEvent, StateTestEvent,
-    SyncResponseBuilder,
+    async_test, mocks::mock_redaction, sync_timeline_event, JoinedRoomBuilder,
+    RoomAccountDataTestEvent, StateTestEvent, SyncResponseBuilder,
 };
 use matrix_sdk_ui::timeline::{EventSendState, RoomExt, TimelineItemContent, VirtualTimelineItem};
 use ruma::{
@@ -262,14 +262,7 @@ async fn test_redact_message() {
     assert!(day_divider.is_day_divider());
 
     // Redacting a remote event works.
-    Mock::given(method("PUT"))
-        .and(path_regex(r"^/_matrix/client/r0/rooms/.*/redact/.*?/.*?"))
-        .and(header("authorization", "Bearer 1234"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
-            "event_id": "$42"
-        })))
-        .mount(&server)
-        .await;
+    mock_redaction(event_id!("$42")).mount(&server).await;
 
     let event_id = first.as_event().unwrap();
 

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

@@ -11,8 +11,11 @@ use matrix_sdk::{
 };
 use matrix_sdk_base::RoomState;
 use matrix_sdk_test::{
-    async_test, test_json, test_json::sync::CUSTOM_ROOM_POWER_LEVELS, EphemeralTestEvent,
-    GlobalAccountDataTestEvent, JoinedRoomBuilder, SyncResponseBuilder, DEFAULT_TEST_ROOM_ID,
+    async_test,
+    mocks::mock_redaction,
+    test_json::{self, sync::CUSTOM_ROOM_POWER_LEVELS},
+    EphemeralTestEvent, GlobalAccountDataTestEvent, JoinedRoomBuilder, SyncResponseBuilder,
+    DEFAULT_TEST_ROOM_ID,
 };
 use ruma::{
     api::client::{membership::Invite3pidInit, receipt::create_receipt::v3::ReceiptType},
@@ -340,22 +343,17 @@ async fn test_room_message_send() {
 async fn test_room_redact() {
     let (client, server) = synced_client().await;
 
-    Mock::given(method("PUT"))
-        .and(path_regex(r"^/_matrix/client/r0/rooms/.*/redact/.*?/.*?"))
-        .and(header("authorization", "Bearer 1234"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(&*test_json::EVENT_ID))
-        .mount(&server)
-        .await;
+    let event_id = event_id!("$h29iv0s8:example.com");
+    mock_redaction(event_id).mount(&server).await;
 
     let room = client.get_room(&DEFAULT_TEST_ROOM_ID).unwrap();
 
-    let event_id = event_id!("$xxxxxxxx:example.com");
-
     let txn_id = TransactionId::new();
     let reason = Some("Indecent material");
-    let response = room.redact(event_id, reason, Some(txn_id)).await.unwrap();
+    let response =
+        room.redact(event_id!("$xxxxxxxx:example.com"), reason, Some(txn_id)).await.unwrap();
 
-    assert_eq!(event_id!("$h29iv0s8:example.com"), response.event_id)
+    assert_eq!(response.event_id, event_id);
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -373,8 +371,7 @@ async fn test_fetch_members_deduplication() {
         .and(path_regex(r"^/_matrix/client/r0/rooms/.*/members"))
         .and(header("authorization", "Bearer 1234"))
         .respond_with(ResponseTemplate::new(200).set_body_json(response_body))
-        // Expect that we're only going to send the request out once.
-        .expect(1..=1)
+        .expect(1)
         .mount(&server)
         .await;
 

crates/matrix-sdk/tests/integration/room/joined.rs

@@ -16,7 +16,9 @@ use matrix_sdk::{
     },
     Client, MemoryStore,
 };
-use matrix_sdk_test::{async_test, InvitedRoomBuilder, JoinedRoomBuilder, LeftRoomBuilder};
+use matrix_sdk_test::{
+    async_test, mocks::mock_redaction, InvitedRoomBuilder, JoinedRoomBuilder, LeftRoomBuilder,
+};
 use ruma::{
     api::MatrixVersion,
     event_id,
@@ -735,13 +737,7 @@ async fn test_cancellation() {
         .await;
 
     // The redact of txn1 will happen because we asked for it previously.
-    Mock::given(method("PUT"))
-        .and(path_regex(r"^/_matrix/client/r0/rooms/.*/redact/.*?/.*?"))
-        .and(header("authorization", "Bearer 1234"))
-        .respond_with(ResponseTemplate::new(200).set_body_json(json!({"event_id": "$1"})))
-        .expect(1)
-        .mount(&server)
-        .await;
+    mock_redaction(event_id!("$1")).expect(1).mount(&server).await;
 
     let handle1 = q.send(RoomMessageEventContent::text_plain("msg1").into()).await.unwrap();
     let handle2 = q.send(RoomMessageEventContent::text_plain("msg2").into()).await.unwrap();

crates/matrix-sdk/tests/integration/send_queue.rs

@@ -27,6 +27,7 @@ serde_json = { workspace = true }
 ctor = "0.2.0"
 tokio = { workspace = true, features = ["rt", "macros"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
+wiremock = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.6", default-features = false, features = ["js"] }

testing/matrix-sdk-test/Cargo.toml

@@ -110,6 +110,10 @@ pub mod __macro_support {
 }
 
 mod event_builder;
+
+#[cfg(not(target_arch = "wasm32"))]
+pub mod mocks;
+
 pub mod notification_settings;
 mod sync_builder;
 pub mod test_json;

testing/matrix-sdk-test/src/lib.rs

@@ -0,0 +1,32 @@
+// Copyright 2024 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Mocks useful to reuse across different testing contexts.
+
+use ruma::EventId;
+use serde_json::json;
+use wiremock::{
+    matchers::{header, method, path_regex},
+    Mock, ResponseTemplate,
+};
+
+/// Mount a mock for a redaction endpoint, that will always work and return a
+/// 200 response.
+pub fn mock_redaction(event_id: &EventId) -> Mock {
+    Mock::given(method("PUT"))
+        .and(path_regex(r"^/_matrix/client/r0/rooms/.*/redact/.*?/.*?"))
+        .and(header("authorization", "Bearer 1234"))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({ "event_id": event_id })))
+        .named("redact")
+}