Skip to main content

ruma_client_api/rtc/livekit/
delegate_delayed_leave.rs

1//! `POST /_matrix/client/*/rtc/livekit/delegate_delayed_leave`
2//!
3//! Delegate the restarting of the delayed leave event of a MatrixRTC slot to the homeserver.
4
5pub mod v1 {
6    //! `/v1/` ([MSC], not yet documented in spec)
7    //!
8    //! [MSC]: https://github.com/matrix-org/matrix-spec-proposals/pull/4195
9
10    use ruma_common::{
11        OwnedRoomId,
12        api::{auth_scheme::AccessToken, request, response},
13        metadata,
14    };
15
16    metadata! {
17        method: POST,
18        rate_limited: true,
19        authentication: AccessToken,
20        history: {
21            unstable => "/_matrix/client/unstable/io.element.msc4195/rtc/livekit/delegate_delayed_leave",
22            stable("org.matrix.msc4195.stable") => "/_matrix/client/v1/rtc/livekit/delegate_delayed_leave",
23        }
24    }
25
26    /// Request type for the `delegate_delayed_leave` endpoint.
27    #[request]
28    pub struct Request {
29        /// The WebSocket URL of the LiveKit SFU that the user has connected to.
30        pub url: String,
31
32        /// The room where the `m.rtc.member` event is present.
33        pub room_id: OwnedRoomId,
34
35        /// The slot ID from the `m.rtc.member` event.
36        pub slot_id: String,
37
38        /// The `member.id` property of the `m.rtc.member` event.
39        pub member_id: String,
40
41        /// The ID of the delayed `m.rtc.member` leave event to delegate.
42        pub delay_id: String,
43    }
44
45    impl Request {
46        /// Creates a new `Request` with the given SFU URL, room ID, slot ID, member ID and delay
47        /// ID.
48        pub fn new(
49            url: String,
50            room_id: OwnedRoomId,
51            slot_id: String,
52            member_id: String,
53            delay_id: String,
54        ) -> Self {
55            Self { url, room_id, slot_id, member_id, delay_id }
56        }
57    }
58
59    /// Response type for the `delegate_delayed_leave` endpoint.
60    #[response]
61    pub struct Response {}
62
63    impl Response {
64        /// Creates a new empty `Response`.
65        pub fn new() -> Self {
66            Self {}
67        }
68    }
69
70    #[cfg(all(test, feature = "client"))]
71    mod tests {
72        use std::{borrow::Cow, collections::BTreeSet};
73
74        use ruma_common::{
75            api::{
76                FeatureFlag, OutgoingRequestExt as _, SupportedVersions,
77                auth_scheme::SendAccessToken,
78            },
79            owned_room_id,
80        };
81        use serde_json::json;
82
83        use super::Request;
84
85        fn serialize_request(
86            supported: SupportedVersions,
87        ) -> (http::request::Parts, serde_json::Value) {
88            let request = Request::new(
89                "wss://livekit.example.com".to_owned(),
90                owned_room_id!("!tDLCaLXijNtYcJZEey:example.com"),
91                "the_id".to_owned(),
92                "xyzABCDEF10123".to_owned(),
93                "1234567890".to_owned(),
94            );
95
96            let (parts, body) = request
97                .try_into_http_request::<Vec<u8>>(
98                    "https://homeserver.tld",
99                    SendAccessToken::IfRequired("auth_tok"),
100                    Cow::Owned(supported),
101                )
102                .unwrap()
103                .into_parts();
104            let body: serde_json::Value = serde_json::from_slice(&body).unwrap();
105
106            (parts, body)
107        }
108
109        fn expected_body() -> serde_json::Value {
110            json!({
111                "url": "wss://livekit.example.com",
112                "room_id": "!tDLCaLXijNtYcJZEey:example.com",
113                "slot_id": "the_id",
114                "member_id": "xyzABCDEF10123",
115                "delay_id": "1234567890",
116            })
117        }
118
119        #[test]
120        fn serialize_request_unstable() {
121            let supported =
122                SupportedVersions { versions: Default::default(), features: Default::default() };
123
124            let (parts, body) = serialize_request(supported);
125
126            assert_eq!("POST", parts.method.as_str());
127            assert_eq!(
128                "https://homeserver.tld/_matrix/client/unstable/io.element.msc4195/rtc/livekit/delegate_delayed_leave",
129                parts.uri.to_string()
130            );
131            assert_eq!(body, expected_body());
132        }
133
134        #[test]
135        fn serialize_request_stable() {
136            let supported = SupportedVersions {
137                versions: Default::default(),
138                features: BTreeSet::from([FeatureFlag::Msc4195Stable]),
139            };
140
141            let (parts, body) = serialize_request(supported);
142
143            assert_eq!("POST", parts.method.as_str());
144            assert_eq!(
145                "https://homeserver.tld/_matrix/client/v1/rtc/livekit/delegate_delayed_leave",
146                parts.uri.to_string()
147            );
148            assert_eq!(body, expected_body());
149        }
150    }
151
152    #[cfg(all(test, feature = "server"))]
153    mod server_tests {
154        use ruma_common::api::IncomingRequestExt as _;
155
156        use super::Request;
157
158        fn deserialize_request(uri: &str) -> Request {
159            let request = http::Request::builder()
160                .method("POST")
161                .uri(uri)
162                .body(
163                    br#"{
164                        "url": "wss://livekit.example.org",
165                        "room_id": "!tDLCaLXijNtYcJZEey:example.org",
166                        "slot_id": "the_id",
167                        "member_id": "xyzABCDEF10123",
168                        "delay_id": "1234567890"
169                    }"# as &[u8],
170                )
171                .unwrap();
172
173            Request::try_from_http_request(request, &[] as &[&str]).unwrap()
174        }
175
176        fn assert_request(request: &Request) {
177            assert_eq!(request.url, "wss://livekit.example.org");
178            assert_eq!(request.room_id, "!tDLCaLXijNtYcJZEey:example.org");
179            assert_eq!(request.slot_id, "the_id");
180            assert_eq!(request.member_id, "xyzABCDEF10123");
181            assert_eq!(request.delay_id, "1234567890");
182        }
183
184        #[test]
185        fn deserialize_request_unstable() {
186            let request = deserialize_request(
187                "/_matrix/client/unstable/io.element.msc4195/rtc/livekit/delegate_delayed_leave",
188            );
189            assert_request(&request);
190        }
191
192        #[test]
193        fn deserialize_request_stable() {
194            let request =
195                deserialize_request("/_matrix/client/v1/rtc/livekit/delegate_delayed_leave");
196            assert_request(&request);
197        }
198    }
199}