Skip to main content

ruma_client_api/delayed_events/
get_delayed_event.rs

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