ruma_client_api/delayed_events/
get_delayed_event.rs

1//! `GET /_matrix/client/*/rooms/{roomId}/delayed_events/{delay_id}`
2//!
3//! Get the information about a delayed event.
4
5pub mod unstable {
6    //! `msc4140` ([MSC])
7    //!
8    //! [MSC]: https://github.com/matrix-org/matrix-spec-proposals/pull/4140
9
10    use ruma_common::{
11        api::{auth_scheme::AccessToken, request, response},
12        metadata,
13    };
14
15    use crate::delayed_events::DelayedEventData;
16
17    metadata! {
18        method: GET,
19        rate_limited: true,
20        authentication: AccessToken,
21        history: {
22            unstable("org.matrix.msc4140") => "/_matrix/client/unstable/org.matrix.msc4140/delayed_events/{delay_id}",
23        }
24    }
25
26    /// Request type for the [`get_delayed_event`](crate::delayed_events::get_delayed_event)
27    /// endpoint
28    #[request]
29    pub struct Request {
30        /// The ID of the requested delayed event.
31        #[ruma_api(path)]
32        pub delay_id: String,
33    }
34
35    /// Response type for the [`get_delayed_event`](crate::delayed_events::get_delayed_event)
36    /// endpoint
37    #[response]
38    pub struct Response {
39        /// The returned delayed event information
40        #[ruma_api(body)]
41        pub delayed_event: DelayedEventData,
42    }
43
44    impl Request {
45        /// Create a new Request object
46        pub fn new(delay_id: String) -> Self {
47            Self { delay_id }
48        }
49    }
50
51    impl Response {
52        /// Create a new Response object
53        pub fn new(delayed_event: DelayedEventData) -> Self {
54            Self { delayed_event }
55        }
56    }
57
58    impl From<DelayedEventData> for Response {
59        fn from(delayed_event: DelayedEventData) -> Self {
60            Self { delayed_event }
61        }
62    }
63
64    #[cfg(all(test, feature = "server"))]
65    mod server_tests {
66        use std::time::Duration;
67
68        use js_int::UInt;
69        use ruma_common::{
70            MilliSecondsSinceUnixEpoch, api::OutgoingResponseExt as _, owned_event_id,
71            owned_room_id, serde::Raw,
72        };
73        use ruma_events::TimelineEventType;
74        use serde_json::{Value as JsonValue, json};
75
76        use super::Response;
77        use crate::delayed_events::DelayedEventData;
78
79        #[test]
80        fn serialize_get_delayed_event_response() {
81            let content = json!({
82                "topic": "test topic"
83            })
84            .to_string();
85
86            let mut event_data = DelayedEventData::new(
87                "a_delay_id".to_owned(),
88                owned_room_id!("!roomid:example.org"),
89                TimelineEventType::RoomTopic,
90                Some("a_state_key".to_owned()),
91                Raw::from_json_string(content).unwrap(),
92                Duration::from_millis(103),
93                MilliSecondsSinceUnixEpoch(UInt::new(70000).unwrap()),
94            );
95            event_data.event_id = Some(owned_event_id!("$event:imaginary.hs"));
96            event_data.finalized_ts = Some(MilliSecondsSinceUnixEpoch(UInt::new(70103).unwrap()));
97
98            let response: http::Response<Vec<u8>> =
99                Response::new(event_data).try_into_http_response().unwrap();
100
101            assert_eq!(
102                json!({
103                    "content": {
104                        "topic": "test topic"
105                    },
106                    "delay": 103,
107                    "delay_id": "a_delay_id",
108                    "event_id": "$event:imaginary.hs",
109                    "finalised_ts": 70103,
110                    "room_id": "!roomid:example.org",
111                    "running_since": 70000,
112                    "state_key": "a_state_key",
113                    "type": "m.room.topic"
114                }),
115                serde_json::from_slice::<JsonValue>(response.body()).unwrap()
116            );
117        }
118    }
119
120    #[cfg(all(test, feature = "client"))]
121    mod client_tests {
122        use std::time::Duration;
123
124        use js_int::UInt;
125        use ruma_common::{
126            MilliSecondsSinceUnixEpoch, api::IncomingResponseExt as _, owned_event_id,
127            owned_room_id,
128        };
129        use ruma_events::TimelineEventType;
130        use serde_json::{Value as JsonValue, json};
131
132        use super::Response;
133
134        #[test]
135        fn deserialize_get_delayed_event_request() {
136            let body = json!({
137                "content": {
138                    "topic": "test topic"
139                },
140                "delay": 103,
141                "delay_id": "a_delay_id",
142                "event_id": "$event:imaginary.hs",
143                "finalised_ts": 70103,
144                "room_id": "!roomid:example.org",
145                "running_since": 70000,
146                "state_key": "a_state_key",
147                "type": "m.room.topic"
148            })
149            .to_string();
150
151            let res = Response::try_from_http_response(
152                http::Response::builder().body(body.as_bytes()).unwrap(),
153            )
154            .unwrap()
155            .delayed_event;
156
157            let content = json!({
158                "topic": "test topic"
159            });
160
161            assert_eq!(res.delay_id, "a_delay_id".to_owned());
162            assert_eq!(res.room_id, owned_room_id!("!roomid:example.org"));
163            assert_eq!(res.event_type, TimelineEventType::RoomTopic);
164            assert_eq!(res.state_key, Some("a_state_key".to_owned()));
165            assert_eq!(res.delay, Duration::from_millis(103));
166            assert_eq!(res.running_since, MilliSecondsSinceUnixEpoch(UInt::new(70000).unwrap()));
167            assert_eq!(
168                serde_json::from_str::<JsonValue>(res.content.json().get()).unwrap(),
169                content
170            );
171            assert!(res.error.is_none());
172            assert_eq!(res.event_id, Some(owned_event_id!("$event:imaginary.hs")));
173            assert_eq!(
174                res.finalized_ts,
175                Some(MilliSecondsSinceUnixEpoch(UInt::new(70103).unwrap()))
176            );
177        }
178    }
179}
ruma_client_api/delayed_events/get_delayed_event.rs

ruma_client_api/delayed_events/
get_delayed_event.rs
