1use crate::errors::{AuthError, Result};
13use serde::{Deserialize, Serialize};
14use std::collections::HashMap;
15use std::sync::Arc;
16use std::time::{SystemTime, UNIX_EPOCH};
17use tokio::sync::RwLock;
18use uuid::Uuid;
19
20pub mod event_types {
24 pub const SESSION_REVOKED: &str =
25 "https://schemas.openid.net/secevent/caep/event-type/session-revoked";
26 pub const TOKEN_CLAIMS_CHANGE: &str =
27 "https://schemas.openid.net/secevent/caep/event-type/token-claims-change";
28 pub const CREDENTIAL_CHANGE: &str =
29 "https://schemas.openid.net/secevent/caep/event-type/credential-change";
30 pub const ASSURANCE_LEVEL_CHANGE: &str =
31 "https://schemas.openid.net/secevent/caep/event-type/assurance-level-change";
32 pub const DEVICE_COMPLIANCE_CHANGE: &str =
33 "https://schemas.openid.net/secevent/caep/event-type/device-compliance-change";
34}
35
36#[derive(Clone, Serialize, Deserialize, PartialEq)]
40#[serde(tag = "format")]
41pub enum SubjectIdentifier {
42 #[serde(rename = "email")]
44 Email { email: String },
45 #[serde(rename = "iss_sub")]
47 IssSub { iss: String, sub: String },
48 #[serde(rename = "opaque")]
50 Opaque { id: String },
51 #[serde(rename = "phone_number")]
53 PhoneNumber { phone_number: String },
54 #[serde(rename = "session_id")]
56 SessionId {
57 session_id: String,
58 #[serde(default)]
59 iss: Option<String>,
60 },
61}
62
63impl std::fmt::Debug for SubjectIdentifier {
64 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
65 use crate::utils::redact::redacted;
66 match self {
67 Self::Email { email } => f.debug_struct("Email").field("email", email).finish(),
68 Self::IssSub { iss, sub } => f
69 .debug_struct("IssSub")
70 .field("iss", iss)
71 .field("sub", sub)
72 .finish(),
73 Self::Opaque { id } => f.debug_struct("Opaque").field("id", id).finish(),
74 Self::PhoneNumber { phone_number } => f
75 .debug_struct("PhoneNumber")
76 .field("phone_number", phone_number)
77 .finish(),
78 Self::SessionId { session_id, iss } => f
79 .debug_struct("SessionId")
80 .field("session_id", &redacted(session_id))
81 .field("iss", iss)
82 .finish(),
83 }
84 }
85}
86
87#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
91#[serde(rename_all = "lowercase")]
92pub enum EventReasonAdmin {
93 Policy,
95 Admin,
97 User,
99}
100
101#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
103#[serde(rename_all = "snake_case")]
104pub enum ChangeType {
105 Create,
106 Revoke,
107 Update,
108 Delete,
109}
110
111#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct CaepEvent {
114 pub jti: String,
116 pub iss: String,
118 pub iat: u64,
120 pub event_type: String,
122 pub subject: SubjectIdentifier,
124 #[serde(default)]
126 pub initiating_entity: Option<EventReasonAdmin>,
127 #[serde(default)]
129 pub reason_admin: Option<String>,
130 #[serde(default)]
132 pub reason_user: Option<String>,
133 #[serde(default)]
135 pub properties: HashMap<String, serde_json::Value>,
136}
137
138impl CaepEvent {
139 pub fn new(iss: &str, event_type: &str, subject: SubjectIdentifier) -> Self {
141 let now = SystemTime::now()
142 .duration_since(UNIX_EPOCH)
143 .unwrap_or_default()
144 .as_secs();
145
146 Self {
147 jti: Uuid::new_v4().to_string(),
148 iss: iss.to_string(),
149 iat: now,
150 event_type: event_type.to_string(),
151 subject,
152 initiating_entity: None,
153 reason_admin: None,
154 reason_user: None,
155 properties: HashMap::new(),
156 }
157 }
158
159 pub fn with_initiating_entity(mut self, entity: EventReasonAdmin) -> Self {
161 self.initiating_entity = Some(entity);
162 self
163 }
164
165 pub fn with_reason_admin(mut self, reason: &str) -> Self {
167 self.reason_admin = Some(reason.to_string());
168 self
169 }
170
171 pub fn with_reason_user(mut self, reason: &str) -> Self {
173 self.reason_user = Some(reason.to_string());
174 self
175 }
176
177 pub fn with_property(mut self, key: &str, value: serde_json::Value) -> Self {
179 self.properties.insert(key.to_string(), value);
180 self
181 }
182
183 pub fn to_set_claims(&self) -> serde_json::Value {
185 let mut events: HashMap<String, serde_json::Value> = HashMap::new();
186 let mut event_body = serde_json::json!({
187 "subject": self.subject,
188 });
189 if let Some(ref entity) = self.initiating_entity {
190 event_body["initiating_entity"] = serde_json::to_value(entity)
191 .expect("serialising a serde value to JSON cannot fail");
192 }
193 if let Some(ref r) = self.reason_admin {
194 event_body["reason_admin"] = serde_json::json!({"en": r});
195 }
196 if let Some(ref r) = self.reason_user {
197 event_body["reason_user"] = serde_json::json!({"en": r});
198 }
199 for (k, v) in &self.properties {
200 event_body[k] = v.clone();
201 }
202 events.insert(self.event_type.clone(), event_body);
203
204 serde_json::json!({
205 "jti": self.jti,
206 "iss": self.iss,
207 "iat": self.iat,
208 "events": events,
209 })
210 }
211}
212
213#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
217#[serde(rename_all = "lowercase")]
218pub enum DeliveryMethod {
219 Push,
221 Poll,
223}
224
225#[derive(Debug, Clone, Serialize, Deserialize)]
227pub struct StreamConfig {
228 pub iss: String,
230 pub aud: Vec<String>,
232 pub events_supported: Vec<String>,
234 pub delivery_method: DeliveryMethod,
236 pub endpoint_url: String,
238}
239
240impl StreamConfig {
241 pub fn builder(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
243 StreamConfigBuilder {
244 iss: iss.into(),
245 aud: Vec::new(),
246 events_supported: Vec::new(),
247 delivery_method: DeliveryMethod::Push,
248 endpoint_url: endpoint_url.into(),
249 }
250 }
251
252 pub fn poll(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
254 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Poll)
255 }
256
257 pub fn push(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
259 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Push)
260 }
261}
262
263pub struct StreamConfigBuilder {
265 iss: String,
266 aud: Vec<String>,
267 events_supported: Vec<String>,
268 delivery_method: DeliveryMethod,
269 endpoint_url: String,
270}
271
272impl StreamConfigBuilder {
273 pub fn audience(mut self, audience: impl Into<String>) -> Self {
275 self.aud.push(audience.into());
276 self
277 }
278
279 pub fn audiences<I, S>(mut self, audiences: I) -> Self
281 where
282 I: IntoIterator<Item = S>,
283 S: Into<String>,
284 {
285 self.aud.extend(audiences.into_iter().map(Into::into));
286 self
287 }
288
289 pub fn supports_event(mut self, event_type: impl Into<String>) -> Self {
291 self.events_supported.push(event_type.into());
292 self
293 }
294
295 pub fn events_supported<I, S>(mut self, events: I) -> Self
297 where
298 I: IntoIterator<Item = S>,
299 S: Into<String>,
300 {
301 self.events_supported
302 .extend(events.into_iter().map(Into::into));
303 self
304 }
305
306 pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
308 self.delivery_method = delivery_method;
309 self
310 }
311
312 pub fn build(self) -> StreamConfig {
314 StreamConfig {
315 iss: self.iss,
316 aud: self.aud,
317 events_supported: self.events_supported,
318 delivery_method: self.delivery_method,
319 endpoint_url: self.endpoint_url,
320 }
321 }
322}
323
324#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
326#[serde(rename_all = "lowercase")]
327pub enum StreamStatus {
328 Enabled,
329 Paused,
330 Disabled,
331}
332
333struct EventStream {
337 config: StreamConfig,
338 status: StreamStatus,
339 events: Vec<CaepEvent>,
340}
341
342pub struct CaepTransmitter {
344 issuer: String,
345 streams: Arc<RwLock<HashMap<String, EventStream>>>,
346}
347
348impl CaepTransmitter {
349 pub fn new(issuer: &str) -> Self {
350 Self {
351 issuer: issuer.to_string(),
352 streams: Arc::new(RwLock::new(HashMap::new())),
353 }
354 }
355
356 pub async fn create_stream(&self, config: StreamConfig) -> String {
358 let stream_id = Uuid::new_v4().to_string();
359 self.streams.write().await.insert(
360 stream_id.clone(),
361 EventStream {
362 config,
363 status: StreamStatus::Enabled,
364 events: Vec::new(),
365 },
366 );
367 stream_id
368 }
369
370 pub async fn get_stream_config(&self, stream_id: &str) -> Option<StreamConfig> {
372 self.streams
373 .read()
374 .await
375 .get(stream_id)
376 .map(|s| s.config.clone())
377 }
378
379 pub async fn set_stream_status(&self, stream_id: &str, status: StreamStatus) -> Result<()> {
381 let mut streams = self.streams.write().await;
382 let stream = streams
383 .get_mut(stream_id)
384 .ok_or_else(|| AuthError::validation("Stream not found"))?;
385 stream.status = status;
386 Ok(())
387 }
388
389 pub async fn get_stream_status(&self, stream_id: &str) -> Option<StreamStatus> {
391 self.streams
392 .read()
393 .await
394 .get(stream_id)
395 .map(|s| s.status.clone())
396 }
397
398 pub async fn delete_stream(&self, stream_id: &str) -> bool {
400 self.streams.write().await.remove(stream_id).is_some()
401 }
402
403 pub async fn emit_session_revoked(
405 &self,
406 subject: SubjectIdentifier,
407 reason: Option<&str>,
408 ) -> Result<CaepEvent> {
409 let mut event = CaepEvent::new(&self.issuer, event_types::SESSION_REVOKED, subject);
410 if let Some(r) = reason {
411 event = event.with_reason_admin(r);
412 }
413 self.dispatch_event(&event).await;
414 Ok(event)
415 }
416
417 pub async fn emit_credential_change(
419 &self,
420 subject: SubjectIdentifier,
421 change_type: ChangeType,
422 ) -> Result<CaepEvent> {
423 let event = CaepEvent::new(&self.issuer, event_types::CREDENTIAL_CHANGE, subject)
424 .with_property(
425 "change_type",
426 serde_json::to_value(&change_type)
427 .expect("serialising a serde value to JSON cannot fail"),
428 );
429 self.dispatch_event(&event).await;
430 Ok(event)
431 }
432
433 pub async fn emit_device_compliance_change(
435 &self,
436 subject: SubjectIdentifier,
437 previous_status: &str,
438 current_status: &str,
439 ) -> Result<CaepEvent> {
440 let event = CaepEvent::new(&self.issuer, event_types::DEVICE_COMPLIANCE_CHANGE, subject)
441 .with_property("previous_status", serde_json::json!(previous_status))
442 .with_property("current_status", serde_json::json!(current_status));
443 self.dispatch_event(&event).await;
444 Ok(event)
445 }
446
447 pub async fn emit_token_claims_change(
451 &self,
452 subject: SubjectIdentifier,
453 claims: HashMap<String, serde_json::Value>,
454 ) -> Result<CaepEvent> {
455 let mut event = CaepEvent::new(&self.issuer, event_types::TOKEN_CLAIMS_CHANGE, subject);
456 event = event.with_property(
457 "claims",
458 serde_json::to_value(&claims).expect("serialising a serde value to JSON cannot fail"),
459 );
460 self.dispatch_event(&event).await;
461 Ok(event)
462 }
463
464 pub async fn emit_assurance_level_change(
468 &self,
469 subject: SubjectIdentifier,
470 current_level: &str,
471 previous_level: &str,
472 change_direction: &str,
473 ) -> Result<CaepEvent> {
474 let event = CaepEvent::new(&self.issuer, event_types::ASSURANCE_LEVEL_CHANGE, subject)
475 .with_property("current_level", serde_json::json!(current_level))
476 .with_property("previous_level", serde_json::json!(previous_level))
477 .with_property("change_direction", serde_json::json!(change_direction));
478 self.dispatch_event(&event).await;
479 Ok(event)
480 }
481
482 pub async fn poll_events(&self, stream_id: &str) -> Result<Vec<CaepEvent>> {
484 let mut streams = self.streams.write().await;
485 let stream = streams
486 .get_mut(stream_id)
487 .ok_or_else(|| AuthError::validation("Stream not found"))?;
488
489 if stream.status != StreamStatus::Enabled {
490 return Err(AuthError::validation("Stream is not enabled"));
491 }
492
493 let events = std::mem::take(&mut stream.events);
494 Ok(events)
495 }
496
497 async fn dispatch_event(&self, event: &CaepEvent) {
499 let mut streams = self.streams.write().await;
500 for stream in streams.values_mut() {
501 if stream.status != StreamStatus::Enabled {
502 continue;
503 }
504 if stream.config.events_supported.is_empty()
506 || stream
507 .config
508 .events_supported
509 .iter()
510 .any(|e| e == &event.event_type)
511 {
512 stream.events.push(event.clone());
513 }
514 }
515 }
516
517 pub async fn active_stream_count(&self) -> usize {
519 self.streams
520 .read()
521 .await
522 .values()
523 .filter(|s| s.status == StreamStatus::Enabled)
524 .count()
525 }
526}
527
528pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
532
533pub struct CaepReceiver {
535 handlers: Arc<RwLock<HashMap<String, Vec<EventHandler>>>>,
536 received_jtis: Arc<RwLock<std::collections::HashSet<String>>>,
537}
538
539impl CaepReceiver {
540 pub fn new() -> Self {
541 Self {
542 handlers: Arc::new(RwLock::new(HashMap::new())),
543 received_jtis: Arc::new(RwLock::new(std::collections::HashSet::new())),
544 }
545 }
546
547 pub async fn on_event(&self, event_type: &str, handler: EventHandler) {
549 self.handlers
550 .write()
551 .await
552 .entry(event_type.to_string())
553 .or_default()
554 .push(handler);
555 }
556
557 pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
561 {
563 let mut jtis = self.received_jtis.write().await;
564 if !jtis.insert(event.jti.clone()) {
565 return Ok(false); }
567 }
568
569 let handlers = self.handlers.read().await;
571 if let Some(handler_list) = handlers.get(&event.event_type) {
572 for handler in handler_list {
573 handler(event);
574 }
575 }
576
577 Ok(true)
578 }
579
580 pub async fn was_processed(&self, jti: &str) -> bool {
582 self.received_jtis.read().await.contains(jti)
583 }
584}
585
586impl Default for CaepReceiver {
587 fn default() -> Self {
588 Self::new()
589 }
590}
591
592#[cfg(test)]
593mod tests {
594 use super::*;
595
596 #[test]
599 fn test_subject_email_serialization() {
600 let sub = SubjectIdentifier::Email {
601 email: "user@example.com".to_string(),
602 };
603 let json = serde_json::to_value(&sub).unwrap();
604 assert_eq!(json["format"], "email");
605 assert_eq!(json["email"], "user@example.com");
606 }
607
608 #[test]
609 fn test_subject_iss_sub_serialization() {
610 let sub = SubjectIdentifier::IssSub {
611 iss: "https://issuer.example".to_string(),
612 sub: "user-123".to_string(),
613 };
614 let json = serde_json::to_value(&sub).unwrap();
615 assert_eq!(json["format"], "iss_sub");
616 }
617
618 #[test]
619 fn test_subject_session_id_serialization() {
620 let sub = SubjectIdentifier::SessionId {
621 session_id: "sess-001".to_string(),
622 iss: Some("https://issuer.example".to_string()),
623 };
624 let json = serde_json::to_value(&sub).unwrap();
625 assert_eq!(json["format"], "session_id");
626 assert_eq!(json["session_id"], "sess-001");
627 }
628
629 #[test]
630 fn test_subject_roundtrip() {
631 let sub = SubjectIdentifier::Opaque {
632 id: "opaque-id-42".to_string(),
633 };
634 let serialized = serde_json::to_string(&sub).unwrap();
635 let deserialized: SubjectIdentifier = serde_json::from_str(&serialized).unwrap();
636 assert_eq!(sub, deserialized);
637 }
638
639 #[test]
642 fn test_event_creation() {
643 let event = CaepEvent::new(
644 "https://issuer.example",
645 event_types::SESSION_REVOKED,
646 SubjectIdentifier::Email {
647 email: "user@x.com".to_string(),
648 },
649 );
650 assert!(!event.jti.is_empty());
651 assert!(event.iat > 0);
652 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
653 }
654
655 #[test]
656 fn test_event_builder_chain() {
657 let event = CaepEvent::new(
658 "https://issuer.example",
659 event_types::CREDENTIAL_CHANGE,
660 SubjectIdentifier::Email {
661 email: "u@x.com".to_string(),
662 },
663 )
664 .with_initiating_entity(EventReasonAdmin::Admin)
665 .with_reason_admin("Password reset")
666 .with_reason_user("Your password was reset by admin")
667 .with_property("change_type", serde_json::json!("revoke"));
668
669 assert_eq!(event.initiating_entity, Some(EventReasonAdmin::Admin));
670 assert_eq!(event.reason_admin.as_deref(), Some("Password reset"));
671 assert!(event.properties.contains_key("change_type"));
672 }
673
674 #[test]
675 fn test_event_to_set_claims() {
676 let event = CaepEvent::new(
677 "https://iss.example",
678 event_types::SESSION_REVOKED,
679 SubjectIdentifier::Email {
680 email: "u@x.com".to_string(),
681 },
682 )
683 .with_reason_admin("Policy violation");
684
685 let claims = event.to_set_claims();
686 assert_eq!(claims["iss"], "https://iss.example");
687 assert!(claims["events"][event_types::SESSION_REVOKED].is_object());
688 let ev = &claims["events"][event_types::SESSION_REVOKED];
689 assert!(ev["subject"].is_object());
690 assert_eq!(ev["reason_admin"]["en"], "Policy violation");
691 }
692
693 #[tokio::test]
696 async fn test_transmitter_create_stream() {
697 let tx = CaepTransmitter::new("https://issuer.example");
698 let config =
699 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
700 .audience("https://receiver.example")
701 .supports_event(event_types::SESSION_REVOKED)
702 .build();
703 let stream_id = tx.create_stream(config.clone()).await;
704 assert!(!stream_id.is_empty());
705 assert_eq!(tx.active_stream_count().await, 1);
706
707 let retrieved = tx.get_stream_config(&stream_id).await.unwrap();
708 assert_eq!(retrieved.iss, config.iss);
709 }
710
711 #[tokio::test]
712 async fn test_transmitter_stream_status() {
713 let tx = CaepTransmitter::new("https://iss.example");
714 let id = tx
715 .create_stream(StreamConfig::poll("https://iss.example", "").build())
716 .await;
717
718 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Enabled));
719
720 tx.set_stream_status(&id, StreamStatus::Paused)
721 .await
722 .unwrap();
723 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Paused));
724 assert_eq!(tx.active_stream_count().await, 0);
725 }
726
727 #[tokio::test]
728 async fn test_transmitter_delete_stream() {
729 let tx = CaepTransmitter::new("https://iss.example");
730 let id = tx.create_stream(StreamConfig::push("", "").build()).await;
731
732 assert!(tx.delete_stream(&id).await);
733 assert!(!tx.delete_stream(&id).await); assert_eq!(tx.active_stream_count().await, 0);
735 }
736
737 #[tokio::test]
738 async fn test_transmitter_emit_session_revoked() {
739 let tx = CaepTransmitter::new("https://iss.example");
740 let id = tx
741 .create_stream(
742 StreamConfig::poll("", "")
743 .supports_event(event_types::SESSION_REVOKED)
744 .build(),
745 )
746 .await;
747
748 let event = tx
749 .emit_session_revoked(
750 SubjectIdentifier::Email {
751 email: "u@x.com".to_string(),
752 },
753 Some("Security policy"),
754 )
755 .await
756 .unwrap();
757
758 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
759
760 let events = tx.poll_events(&id).await.unwrap();
761 assert_eq!(events.len(), 1);
762 assert_eq!(events[0].jti, event.jti);
763
764 let events2 = tx.poll_events(&id).await.unwrap();
766 assert!(events2.is_empty());
767 }
768
769 #[tokio::test]
770 async fn test_transmitter_event_filtering() {
771 let tx = CaepTransmitter::new("https://iss.example");
772
773 let id = tx
775 .create_stream(
776 StreamConfig::poll("", "")
777 .supports_event(event_types::SESSION_REVOKED)
778 .build(),
779 )
780 .await;
781
782 tx.emit_credential_change(
784 SubjectIdentifier::Email {
785 email: "u@x.com".to_string(),
786 },
787 ChangeType::Revoke,
788 )
789 .await
790 .unwrap();
791
792 let events = tx.poll_events(&id).await.unwrap();
793 assert!(events.is_empty());
794 }
795
796 #[tokio::test]
797 async fn test_transmitter_paused_stream_no_events() {
798 let tx = CaepTransmitter::new("https://iss.example");
799 let id = tx.create_stream(StreamConfig::poll("", "").build()).await;
800
801 tx.set_stream_status(&id, StreamStatus::Paused)
802 .await
803 .unwrap();
804
805 tx.emit_session_revoked(
806 SubjectIdentifier::Email {
807 email: "u@x.com".to_string(),
808 },
809 None,
810 )
811 .await
812 .unwrap();
813
814 assert!(tx.poll_events(&id).await.is_err());
816 }
817
818 #[tokio::test]
821 async fn test_receiver_process_event() {
822 let rx = CaepReceiver::new();
823 let called = Arc::new(std::sync::atomic::AtomicBool::new(false));
824 let called_clone = called.clone();
825
826 rx.on_event(
827 event_types::SESSION_REVOKED,
828 Arc::new(move |_event| {
829 called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
830 }),
831 )
832 .await;
833
834 let event = CaepEvent::new(
835 "https://iss.example",
836 event_types::SESSION_REVOKED,
837 SubjectIdentifier::Email {
838 email: "u@x.com".to_string(),
839 },
840 );
841
842 let processed = rx.process_event(&event).await.unwrap();
843 assert!(processed);
844 assert!(called.load(std::sync::atomic::Ordering::SeqCst));
845 }
846
847 #[test]
848 fn test_stream_config_builder() {
849 let config =
850 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
851 .audience("https://receiver.example")
852 .audiences(["https://backup.example"])
853 .supports_event(event_types::SESSION_REVOKED)
854 .events_supported([event_types::CREDENTIAL_CHANGE])
855 .build();
856
857 assert_eq!(config.delivery_method, DeliveryMethod::Poll);
858 assert_eq!(config.aud.len(), 2);
859 assert_eq!(config.events_supported.len(), 2);
860 }
861
862 #[tokio::test]
863 async fn test_receiver_deduplication() {
864 let rx = CaepReceiver::new();
865 let event = CaepEvent::new(
866 "https://iss.example",
867 event_types::CREDENTIAL_CHANGE,
868 SubjectIdentifier::Opaque {
869 id: "x".to_string(),
870 },
871 );
872
873 let first = rx.process_event(&event).await.unwrap();
874 assert!(first);
875
876 let second = rx.process_event(&event).await.unwrap();
877 assert!(!second); assert!(rx.was_processed(&event.jti).await);
880 }
881
882 #[tokio::test]
883 async fn test_receiver_unhandled_event_type() {
884 let rx = CaepReceiver::new();
885 let event = CaepEvent::new(
886 "https://iss.example",
887 "custom:unknown-event",
888 SubjectIdentifier::Opaque {
889 id: "x".to_string(),
890 },
891 );
892 let processed = rx.process_event(&event).await.unwrap();
894 assert!(processed);
895 }
896
897 #[test]
900 fn test_delivery_method_serialization() {
901 assert_eq!(
902 serde_json::to_string(&DeliveryMethod::Push).unwrap(),
903 r#""push""#
904 );
905 assert_eq!(
906 serde_json::to_string(&DeliveryMethod::Poll).unwrap(),
907 r#""poll""#
908 );
909 }
910}