WidgetDriver: integration tests for the toDevice feature.

Author: toger5

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

@@ -778,6 +778,56 @@ impl MatrixMockServer {
         self.mock_endpoint(mock, DeleteRoomKeysVersionEndpoint).expect_default_access_token()
     }
 
+    /// Creates a prebuilt mock for the `/sendToDevice` endpoint.
+    ///
+    /// This mock can be used to simulate sending to-device messages in tests.
+    /// # Examples
+    ///
+    /// ```
+    /// # #[cfg(feature = "e2e-encryption")]
+    /// # {
+    /// # tokio_test::block_on(async {
+    /// use std::collections::BTreeMap;
+    /// use matrix_sdk::{
+    ///     ruma::{
+    ///         serde::Raw,
+    ///         api::client::to_device::send_event_to_device::v3::Request as ToDeviceRequest,
+    ///         to_device::DeviceIdOrAllDevices,
+    ///         user_id,owned_device_id
+    ///     },
+    ///     test_utils::mocks::MatrixMockServer,
+    /// };
+    /// use serde_json::json;
+    ///
+    /// let mock_server = MatrixMockServer::new().await;
+    /// let client = mock_server.client_builder().build().await;
+    ///
+    /// mock_server.mock_send_to_device().ok().mock_once().mount().await;
+    ///
+    /// let request = ToDeviceRequest::new_raw(
+    ///     "m.custom.event".into(),
+    ///     "txn_id".into(),
+    /// BTreeMap::from([
+    /// (user_id!("@alice:localhost").to_owned(), BTreeMap::from([(
+    ///     DeviceIdOrAllDevices::AllDevices,
+    ///     Raw::new(&ruma::events::AnyToDeviceEventContent::Dummy(ruma::events::dummy::ToDeviceDummyEventContent {})).unwrap(),
+    /// )])),
+    /// ])
+    /// );
+    ///
+    /// client
+    ///     .send(request)
+    ///     .await
+    ///     .expect("We should be able to send a to-device message");
+    /// # anyhow::Ok(()) });
+    /// # }
+    /// ```
+    pub fn mock_send_to_device(&self) -> MockEndpoint<'_, SendToDeviceEndpoint> {
+        let mock =
+            Mock::given(method("PUT")).and(path_regex(r"^/_matrix/client/v3/sendToDevice/.*/.*"));
+        self.mock_endpoint(mock, SendToDeviceEndpoint).expect_default_access_token()
+    }
+
     /// Create a prebuilt mock for getting the room members in a room.
     ///
     /// # Examples
@@ -2315,6 +2365,17 @@ impl<'a> MockEndpoint<'a, DeleteRoomKeysVersionEndpoint> {
     }
 }
 
+/// A prebuilt mock for the `/sendToDevice` endpoint.
+///
+/// This mock can be used to simulate sending to-device messages in tests.
+pub struct SendToDeviceEndpoint;
+impl<'a> MockEndpoint<'a, SendToDeviceEndpoint> {
+    /// Returns a successful response with default data.
+    pub fn ok(self) -> MatrixMock<'a> {
+        self.respond_with(ResponseTemplate::new(200).set_body_json(json!({})))
+    }
+}
+
 /// A prebuilt mock for `GET /members` request.
 pub struct GetRoomMembersEndpoint;
 

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

@@ -85,7 +85,7 @@ async fn run_test_driver(
 
 async fn recv_message(driver_handle: &WidgetDriverHandle) -> JsonObject {
     let fut = pin!(driver_handle.recv());
-    let msg = timeout(fut, Duration::from_secs(1)).await.unwrap();
+    let msg = timeout(fut, Duration::from_secs(20)).await.unwrap();
     serde_json::from_str(&msg.unwrap()).unwrap()
 }
 
@@ -95,15 +95,15 @@ async fn send_request(
     action: &str,
     data: impl Serialize,
 ) {
-    let sent = driver_handle
-        .send(json_string!({
-            "api": "fromWidget",
-            "widgetId": WIDGET_ID,
-            "requestId": request_id,
-            "action": action,
-            "data": data,
-        }))
-        .await;
+    let json_string = json_string!({
+        "api": "fromWidget",
+        "widgetId": WIDGET_ID,
+        "requestId": request_id,
+        "action": action,
+        "data": data,
+    });
+    println!("Json string sent from the widget {}", json_string);
+    let sent = driver_handle.send(json_string).await;
     assert!(sent);
 }
 
@@ -381,6 +381,8 @@ async fn test_receive_live_events() {
             "org.matrix.msc2762.receive.event:m.room.message#m.text",
             "org.matrix.msc2762.receive.state_event:m.room.name#",
             "org.matrix.msc2762.receive.state_event:m.room.member#@example:localhost",
+            "org.matrix.msc2762.receive.state_event:m.room.member#@example:localhost",
+            "org.matrix.msc3819.receive.to_device:my.custom.to.device"
         ]),
     )
     .await;
@@ -417,32 +419,63 @@ async fn test_receive_live_events() {
                     // set room name - matches filter #3
                     .add_timeline_event(f.room_name("New Room Name").sender(&BOB)),
             );
+            // to device message - doesn't match
+            sync_builder.add_to_device_event(json!({
+              "sender": "@alice:example.com",
+              "type": "m.not_matching.to.device",
+              "content": {
+                "a": "test",
+              }
+            }));
+            // to device message - matches filter #6
+            sync_builder.add_to_device_event(json!({
+                    "sender": "@alice:example.com",
+                    "type": "my.custom.to.device",
+                    "content": {
+                      "a": "test",
+                    }
+                  }
+            ));
         })
         .await;
 
-    let msg = recv_message(&driver_handle).await;
-    assert_eq!(msg["api"], "toWidget");
-    assert_eq!(msg["action"], "send_event");
-    assert_eq!(msg["data"]["type"], "m.room.message");
-    assert_eq!(msg["data"]["room_id"], ROOM_ID.as_str());
-    assert_eq!(msg["data"]["content"]["msgtype"], "m.text");
-    assert_eq!(msg["data"]["content"]["body"], "simple text message");
-
-    let msg = recv_message(&driver_handle).await;
-    assert_eq!(msg["api"], "toWidget");
-    assert_eq!(msg["action"], "send_event");
-    assert_eq!(msg["data"]["type"], "m.room.member");
-    assert_eq!(msg["data"]["room_id"], ROOM_ID.as_str());
-    assert_eq!(msg["data"]["state_key"], "@example:localhost");
-    assert_eq!(msg["data"]["content"]["membership"], "join");
-    assert_eq!(msg["data"]["unsigned"]["prev_content"]["membership"], "join");
+    // The to device and room events are racing -> we dont know the order and just
+    // need to store them separately.
+    let mut to_device: JsonObject = JsonObject::new();
+    let mut events = vec![];
+    for _ in 0..4 {
+        let msg = recv_message(&driver_handle).await;
+        if msg["action"] == "send_to_device" {
+            to_device = msg;
+        } else {
+            events.push(msg);
+        }
+    }
 
-    let msg = recv_message(&driver_handle).await;
-    assert_eq!(msg["api"], "toWidget");
-    assert_eq!(msg["action"], "send_event");
-    assert_eq!(msg["data"]["type"], "m.room.name");
-    assert_eq!(msg["data"]["sender"], BOB.as_str());
-    assert_eq!(msg["data"]["content"]["name"], "New Room Name");
+    assert_eq!(events[0]["api"], "toWidget");
+    assert_eq!(events[0]["action"], "send_event");
+    assert_eq!(events[0]["data"]["type"], "m.room.message");
+    assert_eq!(events[0]["data"]["room_id"], ROOM_ID.as_str());
+    assert_eq!(events[0]["data"]["content"]["msgtype"], "m.text");
+    assert_eq!(events[0]["data"]["content"]["body"], "simple text message");
+
+    assert_eq!(events[1]["api"], "toWidget");
+    assert_eq!(events[1]["action"], "send_event");
+    assert_eq!(events[1]["data"]["type"], "m.room.member");
+    assert_eq!(events[1]["data"]["room_id"], ROOM_ID.as_str());
+    assert_eq!(events[1]["data"]["state_key"], "@example:localhost");
+    assert_eq!(events[1]["data"]["content"]["membership"], "join");
+    assert_eq!(events[1]["data"]["unsigned"]["prev_content"]["membership"], "join");
+
+    assert_eq!(events[2]["api"], "toWidget");
+    assert_eq!(events[2]["action"], "send_event");
+    assert_eq!(events[2]["data"]["type"], "m.room.name");
+    assert_eq!(events[2]["data"]["sender"], BOB.as_str());
+    assert_eq!(events[2]["data"]["content"]["name"], "New Room Name");
+
+    assert_eq!(to_device["api"], "toWidget");
+    assert_eq!(to_device["action"], "send_to_device");
+    assert_eq!(to_device["data"]["type"], "my.custom.to.device");
 
     // No more messages from the driver
     assert_matches!(recv_message(&driver_handle).now_or_never(), None);
@@ -816,7 +849,6 @@ async fn test_send_redaction() {
         ]),
     )
     .await;
-
     mock_server.mock_room_redact().ok(event_id!("$redact_event_id")).mock_once().mount().await;
 
     send_request(
@@ -843,6 +875,104 @@ async fn test_send_redaction() {
     assert_eq!(redact_room_id, "!a98sd12bjh:example.org");
 }
 
+async fn send_to_device_test_helper(
+    request_id: &str,
+    data: JsonValue,
+    expected_response: JsonValue,
+    calls: u64,
+) -> JsonValue {
+    let (_, mock_server, driver_handle) = run_test_driver(false).await;
+
+    negotiate_capabilities(
+        &driver_handle,
+        json!([
+            "org.matrix.msc3819.send.to_device:my.custom.to_device_type",
+            "org.matrix.msc3819.send.to_device:my.other_type"
+        ]),
+    )
+    .await;
+
+    mock_server.mock_send_to_device().ok().expect(calls).mount().await;
+
+    send_request(&driver_handle, request_id, "send_to_device", data).await;
+
+    // Receive the response
+    let msg = recv_message(&driver_handle).await;
+    assert_eq!(msg["api"], "fromWidget");
+    assert_eq!(msg["action"], "send_to_device");
+    let response = msg["response"].clone();
+    assert_eq!(
+        serde_json::to_string(&response).unwrap(),
+        serde_json::to_string(&expected_response).unwrap()
+    );
+
+    response
+}
+
+#[async_test]
+async fn test_send_to_device_event() {
+    send_to_device_test_helper(
+        "id_my.custom.to_device_type",
+        json!({
+            "type":"my.custom.to_device_type",
+            "encrypted": false,
+            "messages":{
+                "@username:test.org": {
+                    "DEVICEID": {
+                        "param1":"test",
+                    },
+                },
+            }
+        }),
+        json! {{}},
+        1,
+    )
+    .await;
+}
+
+#[async_test]
+async fn test_error_to_device_event_no_permission() {
+    send_to_device_test_helper(
+        "id_my.unallowed_type",
+        json!({
+            "type": "my.unallowed_type",
+            "encrypted": false,
+            "messages": {
+                "@username:test.org": {
+                    "DEVICEID": {
+                        "param1":"test",
+                    },
+                },
+            }
+        }),
+        // this means the server did not get the correct event type
+        json! {{"error": {"message": "Not allowed to send to-device message of type: my.unallowed_type"}}},
+        0
+    )
+    .await;
+}
+
+#[async_test]
+async fn test_send_encrypted_to_device_event() {
+    send_to_device_test_helper(
+        "my.custom.to_device_type",
+        json!({
+            "type": "my.custom.to_device_type",
+            "encrypted": true,
+            "messages":{
+                "@username:test.org": {
+                    "DEVICEID": {
+                        "param1":"test",
+                    },
+                },
+            }
+        }),
+        json! {{}},
+        1,
+    )
+    .await;
+}
+
 async fn negotiate_capabilities(driver_handle: &WidgetDriverHandle, caps: JsonValue) {
     {
         // Receive toWidget capabilities request

testing/matrix-sdk-test/src/sync_builder/mod.rs

@@ -8,7 +8,7 @@ use ruma::{
         },
         IncomingResponse,
     },
-    events::{presence::PresenceEvent, AnyGlobalAccountDataEvent},
+    events::{presence::PresenceEvent, AnyGlobalAccountDataEvent, AnyToDeviceEvent},
     serde::Raw,
     OwnedRoomId, OwnedUserId, UserId,
 };
@@ -58,6 +58,7 @@ pub struct SyncResponseBuilder {
     batch_counter: i64,
     /// The device lists of the user.
     changed_device_lists: Vec<OwnedUserId>,
+    to_device_events: Vec<Raw<AnyToDeviceEvent>>,
 }
 
 impl SyncResponseBuilder {
@@ -162,6 +163,12 @@ impl SyncResponseBuilder {
         self
     }
 
+    /// Add a to device event.
+    pub fn add_to_device_event(&mut self, event: JsonValue) -> &mut Self {
+        self.to_device_events.push(from_json_value(event).unwrap());
+        self
+    }
+
     /// Builds a sync response as a JSON Value containing the events we queued
     /// so far.
     ///
@@ -191,7 +198,7 @@ impl SyncResponseBuilder {
                     "knock": self.knocked_rooms,
                 },
                 "to_device": {
-                    "events": []
+                    "events": self.to_device_events,
                 },
                 "presence": {
                     "events": self.presence,