ruma_client_api/delayed_events/
get_delayed_event.rs1pub mod msc4140 {
6 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]
28 pub struct Request {
29 #[ruma_api(path)]
31 pub delay_id: String,
32 }
33
34 #[response]
36 pub struct Response {
37 #[ruma_api(body)]
39 pub delayed_event: DelayedEventData,
40 }
41
42 impl Request {
43 pub fn new(delay_id: String) -> Self {
45 Self { delay_id }
46 }
47 }
48
49 impl Response {
50 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}