libkeri/keri/core/eventing/
reply.rs1use crate::cesr::Versionage;
2use crate::keri::core::serdering::{SadValue, SerderKERI};
3use crate::keri::{versify, Ilks, KERIError, Kinds};
4use chrono::{DateTime, Utc};
5use indexmap::IndexMap;
6
7pub struct ReplyEventBuilder {
9 route: String,
10 data: Option<IndexMap<String, SadValue>>,
11 stamp: Option<String>,
12 version: String,
13 kind: String,
14}
15
16impl ReplyEventBuilder {
17 pub fn new() -> Self {
19 Self {
20 route: String::new(),
21 data: None,
22 stamp: None,
23 version: "KERI10JSON000000_".to_string(),
24 kind: "JSON".to_string(),
25 }
26 }
27
28 pub fn with_route(mut self, route: String) -> Self {
34 self.route = route;
35 self
36 }
37
38 pub fn with_data(mut self, data: IndexMap<String, SadValue>) -> Self {
43 self.data = Some(data);
44 self
45 }
46
47 pub fn with_stamp(mut self, stamp: String) -> Self {
52 self.stamp = Some(stamp);
53 self
54 }
55
56 pub fn with_version(mut self, version: String) -> Self {
58 self.version = version;
59 self
60 }
61
62 pub fn with_kind(mut self, kind: String) -> Self {
64 self.kind = kind;
65 self
66 }
67
68 pub fn build(self) -> Result<SerderKERI, KERIError> {
70 if !Kinds::contains(&self.kind) {
71 return Err(KERIError::ValueError(format!(
72 "Invalid kind = {} for rpy.",
73 self.kind
74 )));
75 }
76
77 let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
79
80 let timestamp = self.stamp.unwrap_or_else(|| {
82 let now: DateTime<Utc> = Utc::now();
83 now.to_rfc3339()
84 });
85
86 let mut ked = IndexMap::new();
88 ked.insert("v".to_string(), SadValue::String(vs));
89 ked.insert("t".to_string(), SadValue::String(Ilks::RPY.to_string()));
90 ked.insert("d".to_string(), SadValue::String("".to_string()));
91 ked.insert("dt".to_string(), SadValue::String(timestamp));
92 ked.insert("r".to_string(), SadValue::String(self.route));
93
94 if let Some(data) = self.data {
95 ked.insert("a".to_string(), SadValue::Object(data));
96 } else {
97 ked.insert("a".to_string(), SadValue::Object(IndexMap::new()));
99 }
100
101 let serder = SerderKERI::from_sad_and_saids(&ked, None)?;
103 Ok(serder)
104 }
105}
106
107#[cfg(test)]
108mod tests {
109 use super::*;
110 use crate::keri::core::serdering::Serder;
111
112 #[test]
113 fn test_reply_event_builder_basic() -> Result<(), KERIError> {
114 let serder = ReplyEventBuilder::new()
116 .with_route("logs/processor".to_string())
117 .build()?;
118
119 let ked = serder.ked();
121
122 assert_eq!(ked["t"].as_str().unwrap(), Ilks::RPY);
124
125 assert_eq!(ked["r"].as_str().unwrap(), "logs/processor");
127
128 assert!(ked.get("dt").is_some());
130 let a = ked["a"].clone();
131 let raw_str = std::str::from_utf8(serder.raw()).expect("bad utf8");
132
133 match &ked["a"] {
135 SadValue::Object(obj) => assert!(obj.is_empty()),
136 _ => panic!("Expected a field to be an object"),
137 }
138
139 Ok(())
140 }
141
142 #[test]
143 fn test_reply_event_with_data() -> Result<(), KERIError> {
144 let mut data = IndexMap::new();
146 data.insert(
147 "d".to_string(),
148 SadValue::String("EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM".to_string()),
149 );
150 data.insert(
151 "i".to_string(),
152 SadValue::String("EAoTNZH3ULvYAfSVPzhzS6baU6JR2nmwyZ-i0d8JZ5CM".to_string()),
153 );
154 data.insert(
155 "name".to_string(),
156 SadValue::String("John Jones".to_string()),
157 );
158 data.insert("role".to_string(), SadValue::String("Founder".to_string()));
159
160 let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
162
163 let serder = ReplyEventBuilder::new()
165 .with_route("logs/processor".to_string())
166 .with_data(data)
167 .with_stamp(timestamp.clone())
168 .build()?;
169
170 let ked = serder.ked();
172
173 assert_eq!(ked["dt"].as_str().unwrap(), timestamp);
175
176 let a = match &ked["a"] {
178 SadValue::Object(obj) => obj,
179 _ => panic!("Expected a field to be an object"),
180 };
181
182 assert_eq!(
183 a["d"].as_str().unwrap(),
184 "EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM"
185 );
186 assert_eq!(
187 a["i"].as_str().unwrap(),
188 "EAoTNZH3ULvYAfSVPzhzS6baU6JR2nmwyZ-i0d8JZ5CM"
189 );
190 assert_eq!(a["name"].as_str().unwrap(), "John Jones");
191 assert_eq!(a["role"].as_str().unwrap(), "Founder");
192
193 Ok(())
194 }
195
196 #[test]
197 fn test_reply_event_custom_version_kind() -> Result<(), KERIError> {
198 let serder = ReplyEventBuilder::new()
200 .with_route("logs/processor".to_string())
201 .with_version("KERI10".to_string())
202 .with_kind("CBOR".to_string())
203 .build()?;
204
205 let ked = serder.ked();
207 let version = ked["v"].as_str().unwrap();
208 assert!(version.starts_with("KERI10CBOR"));
209
210 Ok(())
211 }
212
213 #[test]
214 fn test_reply_event_invalid_kind() -> Result<(), KERIError> {
215 let result = ReplyEventBuilder::new()
217 .with_kind("INVALID".to_string())
218 .build();
219
220 assert!(result.is_err());
221 let err = result.unwrap_err();
222 assert!(err.to_string().contains("Invalid kind"));
223
224 Ok(())
225 }
226
227 #[test]
228 fn test_reply_event_said_derivation() -> Result<(), KERIError> {
229 let serder = ReplyEventBuilder::new()
231 .with_route("logs/processor".to_string())
232 .build()?;
233
234 let said = serder.said().expect("Failed to get SAID");
236
237 assert!(said.starts_with('E'));
239
240 assert_eq!(serder.ked()["d"].as_str().unwrap(), said);
242
243 Ok(())
244 }
245
246 #[test]
247 fn test_reply_matches_python_example() -> Result<(), KERIError> {
248 let mut data = IndexMap::new();
250 data.insert(
251 "d".to_string(),
252 SadValue::String("EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM".to_string()),
253 );
254 data.insert(
255 "i".to_string(),
256 SadValue::String("EAoTNZH3ULvYAfSVPzhzS6baU6JR2nmwyZ-i0d8JZ5CM".to_string()),
257 );
258 data.insert(
259 "name".to_string(),
260 SadValue::String("John Jones".to_string()),
261 );
262 data.insert("role".to_string(), SadValue::String("Founder".to_string()));
263
264 let serder = ReplyEventBuilder::new()
265 .with_route("logs/processor".to_string())
266 .with_data(data)
267 .with_stamp("2020-08-22T17:50:12.988921+00:00".to_string())
268 .build()?;
269
270 let ked = serder.ked();
271
272 assert_eq!(ked["t"].as_str().unwrap(), Ilks::RPY);
274 assert_eq!(
275 ked["dt"].as_str().unwrap(),
276 "2020-08-22T17:50:12.988921+00:00"
277 );
278 assert_eq!(ked["r"].as_str().unwrap(), "logs/processor");
279
280 let a = match &ked["a"] {
281 SadValue::Object(obj) => obj,
282 _ => panic!("Expected a field to be an object"),
283 };
284
285 assert_eq!(
286 a["d"].as_str().unwrap(),
287 "EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM"
288 );
289 assert_eq!(
290 a["i"].as_str().unwrap(),
291 "EAoTNZH3ULvYAfSVPzhzS6baU6JR2nmwyZ-i0d8JZ5CM"
292 );
293 assert_eq!(a["name"].as_str().unwrap(), "John Jones");
294 assert_eq!(a["role"].as_str().unwrap(), "Founder");
295
296 Ok(())
297 }
298
299 #[test]
300 fn test_reply_event_builder_serialization() -> Result<(), KERIError> {
301 let mut data = IndexMap::new();
303 data.insert(
304 "d".to_string(),
305 SadValue::String("EaU6JR2nmwyZ-i0d8JZAoTNZH3ULvYAfSVPzhzS6b5CM".to_string()),
306 );
307 data.insert(
308 "i".to_string(),
309 SadValue::String("EAoTNZH3ULvYAfSVPzhzS6baU6JR2nmwyZ-i0d8JZ5CM".to_string()),
310 );
311 data.insert(
312 "name".to_string(),
313 SadValue::String("John Jones".to_string()),
314 );
315 data.insert("role".to_string(), SadValue::String("Founder".to_string()));
316
317 let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
319
320 let serder = ReplyEventBuilder::new()
322 .with_route("logs/processor".to_string())
323 .with_data(data)
324 .with_stamp(timestamp)
325 .build()?;
326
327 let raw = serder.raw();
329
330 let raw_str = std::str::from_utf8(&raw).expect("bad utf8");
333
334 assert!(raw_str.starts_with("{\"v\":\"KERI10JSON"));
336 assert!(raw_str.contains("\"t\":\"rpy\""));
337
338 assert!(raw_str.contains("\"John Jones\""));
340 assert!(raw_str.contains("\"Founder\""));
341
342 assert!(raw_str.contains("\"r\":\"logs/processor\""));
344
345 Ok(())
346 }
347
348 #[test]
349 fn test_reply_with_empty_route() -> Result<(), KERIError> {
350 let serder = ReplyEventBuilder::new().build()?;
352
353 let ked = serder.ked();
354
355 assert_eq!(ked["t"].as_str().unwrap(), Ilks::RPY);
357
358 assert_eq!(ked["r"].as_str().unwrap(), "");
360
361 Ok(())
362 }
363
364 #[test]
365 fn test_reply_event_for_role_add() -> Result<(), KERIError> {
366 let route = "/end/role/add".to_string();
368
369 let mut data = IndexMap::new();
371 data.insert(
372 "cid".to_string(),
373 SadValue::String("BLK_YxcmK_sAsSW1CbNLJl_FA0gw0FKDuPr_xUwKcj7y".to_string()),
374 );
375 data.insert("role".to_string(), SadValue::String("watcher".to_string()));
376 data.insert(
377 "eid".to_string(),
378 SadValue::String("BF6YSJGAtVNmq3b7dpBi04Q0YdqvTfsk9PFkkZaR8LRr".to_string()),
379 );
380
381 let timestamp = "2021-01-01T00:00:00.000000+00:00".to_string();
383
384 let serder = ReplyEventBuilder::new()
386 .with_route(route)
387 .with_data(data)
388 .with_stamp(timestamp)
389 .build()?;
390
391 let ked = serder.ked();
393 assert_eq!(
394 ked["dt"].as_str().unwrap(),
395 "2021-01-01T00:00:00.000000+00:00"
396 );
397
398 let raw = serder.raw();
400
401 let expected = b"{\"v\":\"KERI10JSON000113_\",\"t\":\"rpy\",\"d\":\"EFlkeg-NociMRXHSGBSqARxV5y7zuT5z-ZpLZAkcoMkk\",\"dt\":\"2021-01-01T00:00:00.000000+00:00\",\"r\":\"/end/role/add\",\"a\":{\"cid\":\"BLK_YxcmK_sAsSW1CbNLJl_FA0gw0FKDuPr_xUwKcj7y\",\"role\":\"watcher\",\"eid\":\"BF6YSJGAtVNmq3b7dpBi04Q0YdqvTfsk9PFkkZaR8LRr\"}}";
403
404 assert_eq!(raw, expected);
406
407 let said = serder.said().expect("Failed to get SAID");
409 assert_eq!(said, "EFlkeg-NociMRXHSGBSqARxV5y7zuT5z-ZpLZAkcoMkk");
410
411 let a = match &ked["a"] {
413 SadValue::Object(obj) => obj,
414 _ => panic!("Expected a field to be an object"),
415 };
416
417 assert_eq!(
418 a["cid"].as_str().unwrap(),
419 "BLK_YxcmK_sAsSW1CbNLJl_FA0gw0FKDuPr_xUwKcj7y"
420 );
421 assert_eq!(a["role"].as_str().unwrap(), "watcher");
422 assert_eq!(
423 a["eid"].as_str().unwrap(),
424 "BF6YSJGAtVNmq3b7dpBi04Q0YdqvTfsk9PFkkZaR8LRr"
425 );
426
427 Ok(())
428 }
429}