Skip to main content

libkeri/keri/core/eventing/
reply.rs

1use 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
7/// Builder for creating KERI reply events
8pub 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    /// Create a new ReplyEventBuilder
18    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    /// Set the route
29    ///
30    /// Parameters:
31    ///   route - namespaced path, '/' delimited, that indicates data flow
32    ///           handler (behavior) to process the reply
33    pub fn with_route(mut self, route: String) -> Self {
34        self.route = route;
35        self
36    }
37
38    /// Set the data attributes
39    ///
40    /// Parameters:
41    ///   data - attribute section of reply
42    pub fn with_data(mut self, data: IndexMap<String, SadValue>) -> Self {
43        self.data = Some(data);
44        self
45    }
46
47    /// Set the timestamp
48    ///
49    /// Parameters:
50    ///   stamp - date-time-stamp RFC-3339 profile of ISO-8601 datetime of creation of message
51    pub fn with_stamp(mut self, stamp: String) -> Self {
52        self.stamp = Some(stamp);
53        self
54    }
55
56    /// Set the version string
57    pub fn with_version(mut self, version: String) -> Self {
58        self.version = version;
59        self
60    }
61
62    /// Set the serialization kind
63    pub fn with_kind(mut self, kind: String) -> Self {
64        self.kind = kind;
65        self
66    }
67
68    /// Build the reply event serder
69    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        // Create versified string
78        let vs = versify("KERI", &Versionage::from(self.version), &self.kind, 0)?;
79
80        // Generate timestamp if not provided
81        let timestamp = self.stamp.unwrap_or_else(|| {
82            let now: DateTime<Utc> = Utc::now();
83            now.to_rfc3339()
84        });
85
86        // Create the key event dict (ked)
87        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            // If no data is provided, use an empty object
98            ked.insert("a".to_string(), SadValue::Object(IndexMap::new()));
99        }
100
101        // Create the serder
102        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        // Create a basic reply
115        let serder = ReplyEventBuilder::new()
116            .with_route("logs/processor".to_string())
117            .build()?;
118
119        // Verify the key event data
120        let ked = serder.ked();
121
122        // Check it's a reply event
123        assert_eq!(ked["t"].as_str().unwrap(), Ilks::RPY);
124
125        // Check basic fields
126        assert_eq!(ked["r"].as_str().unwrap(), "logs/processor");
127
128        // Check dt field exists (timestamp)
129        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        // Check a field is an empty object
134        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        // Create data
145        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        // Set a specific timestamp
161        let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
162
163        // Create a reply with data
164        let serder = ReplyEventBuilder::new()
165            .with_route("logs/processor".to_string())
166            .with_data(data)
167            .with_stamp(timestamp.clone())
168            .build()?;
169
170        // Verify the key event data
171        let ked = serder.ked();
172
173        // Check timestamp
174        assert_eq!(ked["dt"].as_str().unwrap(), timestamp);
175
176        // Check data attributes
177        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        // Create a reply with custom version and kind
199        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        // Verify the version string
206        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        // Try to create a reply with invalid kind
216        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        // Create a reply
230        let serder = ReplyEventBuilder::new()
231            .with_route("logs/processor".to_string())
232            .build()?;
233
234        // Get the SAID (self-addressing identifier)
235        let said = serder.said().expect("Failed to get SAID");
236
237        // SAID should start with 'E' for BLAKE3_256 digest
238        assert!(said.starts_with('E'));
239
240        // Verify the SAID is in the 'd' field of the event
241        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        // Recreate the Python example from the docstring
249        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        // Check expected fields from Python example
273        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        // Create data
302        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        // Create a timestamp matching the Python example
318        let timestamp = "2020-08-22T17:50:12.988921+00:00".to_string();
319
320        // Create the reply event
321        let serder = ReplyEventBuilder::new()
322            .with_route("logs/processor".to_string())
323            .with_data(data)
324            .with_stamp(timestamp)
325            .build()?;
326
327        // Get raw serialized bytes
328        let raw = serder.raw();
329
330        // The SAID will be dynamically generated, so we can't check the exact raw bytes
331        // but we can check that it starts and ends correctly
332        let raw_str = std::str::from_utf8(&raw).expect("bad utf8");
333
334        // Check that it starts with the correct version and type
335        assert!(raw_str.starts_with("{\"v\":\"KERI10JSON"));
336        assert!(raw_str.contains("\"t\":\"rpy\""));
337
338        // Check that it contains our data
339        assert!(raw_str.contains("\"John Jones\""));
340        assert!(raw_str.contains("\"Founder\""));
341
342        // Should have a field for route
343        assert!(raw_str.contains("\"r\":\"logs/processor\""));
344
345        Ok(())
346    }
347
348    #[test]
349    fn test_reply_with_empty_route() -> Result<(), KERIError> {
350        // Create a reply with empty route (should be valid)
351        let serder = ReplyEventBuilder::new().build()?;
352
353        let ked = serder.ked();
354
355        // Check it's a reply event
356        assert_eq!(ked["t"].as_str().unwrap(), Ilks::RPY);
357
358        // Check route is empty string
359        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        // Define the route
367        let route = "/end/role/add".to_string();
368
369        // Create data
370        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        // Create a timestamp matching the Python test
382        let timestamp = "2021-01-01T00:00:00.000000+00:00".to_string();
383
384        // Create the reply event
385        let serder = ReplyEventBuilder::new()
386            .with_route(route)
387            .with_data(data)
388            .with_stamp(timestamp)
389            .build()?;
390
391        // Verify the timestamp
392        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        // Get the raw serialized output
399        let raw = serder.raw();
400
401        // Expected raw output from Python test
402        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        // Compare raw output with expected
405        assert_eq!(raw, expected);
406
407        // Get and check the SAID
408        let said = serder.said().expect("Failed to get SAID");
409        assert_eq!(said, "EFlkeg-NociMRXHSGBSqARxV5y7zuT5z-ZpLZAkcoMkk");
410
411        // Verify the data field contains the expected values
412        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}