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 let encoded = match entity {
196 EventReasonAdmin::Policy => "policy",
197 EventReasonAdmin::Admin => "admin",
198 EventReasonAdmin::User => "user",
199 };
200 event_body["initiating_entity"] = serde_json::Value::String(encoded.to_string());
201 }
202 if let Some(ref r) = self.reason_admin {
203 event_body["reason_admin"] = serde_json::json!({"en": r});
204 }
205 if let Some(ref r) = self.reason_user {
206 event_body["reason_user"] = serde_json::json!({"en": r});
207 }
208 for (k, v) in &self.properties {
209 event_body[k] = v.clone();
210 }
211 events.insert(self.event_type.clone(), event_body);
212
213 serde_json::json!({
214 "jti": self.jti,
215 "iss": self.iss,
216 "iat": self.iat,
217 "events": events,
218 })
219 }
220}
221
222#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
226#[serde(rename_all = "lowercase")]
227pub enum DeliveryMethod {
228 Push,
230 Poll,
232}
233
234#[derive(Debug, Clone, Serialize, Deserialize)]
236pub struct StreamConfig {
237 pub iss: String,
239 pub aud: Vec<String>,
241 pub events_supported: Vec<String>,
243 pub delivery_method: DeliveryMethod,
245 pub endpoint_url: String,
247}
248
249impl StreamConfig {
250 pub fn builder(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
252 StreamConfigBuilder {
253 iss: iss.into(),
254 aud: Vec::new(),
255 events_supported: Vec::new(),
256 delivery_method: DeliveryMethod::Push,
257 endpoint_url: endpoint_url.into(),
258 }
259 }
260
261 pub fn poll(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
263 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Poll)
264 }
265
266 pub fn push(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
268 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Push)
269 }
270}
271
272pub struct StreamConfigBuilder {
274 iss: String,
275 aud: Vec<String>,
276 events_supported: Vec<String>,
277 delivery_method: DeliveryMethod,
278 endpoint_url: String,
279}
280
281impl StreamConfigBuilder {
282 pub fn audience(mut self, audience: impl Into<String>) -> Self {
284 self.aud.push(audience.into());
285 self
286 }
287
288 pub fn audiences<I, S>(mut self, audiences: I) -> Self
290 where
291 I: IntoIterator<Item = S>,
292 S: Into<String>,
293 {
294 self.aud.extend(audiences.into_iter().map(Into::into));
295 self
296 }
297
298 pub fn supports_event(mut self, event_type: impl Into<String>) -> Self {
300 self.events_supported.push(event_type.into());
301 self
302 }
303
304 pub fn events_supported<I, S>(mut self, events: I) -> Self
306 where
307 I: IntoIterator<Item = S>,
308 S: Into<String>,
309 {
310 self.events_supported
311 .extend(events.into_iter().map(Into::into));
312 self
313 }
314
315 pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
317 self.delivery_method = delivery_method;
318 self
319 }
320
321 pub fn build(self) -> StreamConfig {
323 StreamConfig {
324 iss: self.iss,
325 aud: self.aud,
326 events_supported: self.events_supported,
327 delivery_method: self.delivery_method,
328 endpoint_url: self.endpoint_url,
329 }
330 }
331}
332
333#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
335#[serde(rename_all = "lowercase")]
336pub enum StreamStatus {
337 Enabled,
338 Paused,
339 Disabled,
340}
341
342struct EventStream {
346 config: StreamConfig,
347 status: StreamStatus,
348 events: Vec<CaepEvent>,
349}
350
351pub struct CaepTransmitter {
353 issuer: String,
354 streams: Arc<RwLock<HashMap<String, EventStream>>>,
355}
356
357impl CaepTransmitter {
358 pub fn new(issuer: &str) -> Self {
359 Self {
360 issuer: issuer.to_string(),
361 streams: Arc::new(RwLock::new(HashMap::new())),
362 }
363 }
364
365 pub async fn create_stream(&self, config: StreamConfig) -> String {
367 let stream_id = Uuid::new_v4().to_string();
368 self.streams.write().await.insert(
369 stream_id.clone(),
370 EventStream {
371 config,
372 status: StreamStatus::Enabled,
373 events: Vec::new(),
374 },
375 );
376 stream_id
377 }
378
379 pub async fn get_stream_config(&self, stream_id: &str) -> Option<StreamConfig> {
381 self.streams
382 .read()
383 .await
384 .get(stream_id)
385 .map(|s| s.config.clone())
386 }
387
388 pub async fn set_stream_status(&self, stream_id: &str, status: StreamStatus) -> Result<()> {
390 let mut streams = self.streams.write().await;
391 let stream = streams
392 .get_mut(stream_id)
393 .ok_or_else(|| AuthError::validation("Stream not found"))?;
394 stream.status = status;
395 Ok(())
396 }
397
398 pub async fn get_stream_status(&self, stream_id: &str) -> Option<StreamStatus> {
400 self.streams
401 .read()
402 .await
403 .get(stream_id)
404 .map(|s| s.status.clone())
405 }
406
407 pub async fn delete_stream(&self, stream_id: &str) -> bool {
409 self.streams.write().await.remove(stream_id).is_some()
410 }
411
412 pub async fn emit_session_revoked(
414 &self,
415 subject: SubjectIdentifier,
416 reason: Option<&str>,
417 ) -> Result<CaepEvent> {
418 let mut event = CaepEvent::new(&self.issuer, event_types::SESSION_REVOKED, subject);
419 if let Some(r) = reason {
420 event = event.with_reason_admin(r);
421 }
422 self.dispatch_event(&event).await;
423 Ok(event)
424 }
425
426 pub async fn emit_credential_change(
428 &self,
429 subject: SubjectIdentifier,
430 change_type: ChangeType,
431 ) -> Result<CaepEvent> {
432 let change_type_value = serde_json::to_value(&change_type).map_err(|e| {
433 AuthError::internal(format!("Failed to serialize CAEP change_type: {e}"))
434 })?;
435 let event = CaepEvent::new(&self.issuer, event_types::CREDENTIAL_CHANGE, subject)
436 .with_property("change_type", change_type_value);
437 self.dispatch_event(&event).await;
438 Ok(event)
439 }
440
441 pub async fn emit_device_compliance_change(
443 &self,
444 subject: SubjectIdentifier,
445 previous_status: &str,
446 current_status: &str,
447 ) -> Result<CaepEvent> {
448 let event = CaepEvent::new(&self.issuer, event_types::DEVICE_COMPLIANCE_CHANGE, subject)
449 .with_property("previous_status", serde_json::json!(previous_status))
450 .with_property("current_status", serde_json::json!(current_status));
451 self.dispatch_event(&event).await;
452 Ok(event)
453 }
454
455 pub async fn emit_token_claims_change(
459 &self,
460 subject: SubjectIdentifier,
461 claims: HashMap<String, serde_json::Value>,
462 ) -> Result<CaepEvent> {
463 let mut event = CaepEvent::new(&self.issuer, event_types::TOKEN_CLAIMS_CHANGE, subject);
464 let claims_value = serde_json::to_value(&claims)
465 .map_err(|e| AuthError::internal(format!("Failed to serialize CAEP claims: {e}")))?;
466 event = event.with_property("claims", claims_value);
467 self.dispatch_event(&event).await;
468 Ok(event)
469 }
470
471 pub async fn emit_assurance_level_change(
475 &self,
476 subject: SubjectIdentifier,
477 current_level: &str,
478 previous_level: &str,
479 change_direction: &str,
480 ) -> Result<CaepEvent> {
481 let event = CaepEvent::new(&self.issuer, event_types::ASSURANCE_LEVEL_CHANGE, subject)
482 .with_property("current_level", serde_json::json!(current_level))
483 .with_property("previous_level", serde_json::json!(previous_level))
484 .with_property("change_direction", serde_json::json!(change_direction));
485 self.dispatch_event(&event).await;
486 Ok(event)
487 }
488
489 pub async fn poll_events(&self, stream_id: &str) -> Result<Vec<CaepEvent>> {
491 let mut streams = self.streams.write().await;
492 let stream = streams
493 .get_mut(stream_id)
494 .ok_or_else(|| AuthError::validation("Stream not found"))?;
495
496 if stream.status != StreamStatus::Enabled {
497 return Err(AuthError::validation("Stream is not enabled"));
498 }
499
500 let events = std::mem::take(&mut stream.events);
501 Ok(events)
502 }
503
504 async fn dispatch_event(&self, event: &CaepEvent) {
506 let mut streams = self.streams.write().await;
507 for stream in streams.values_mut() {
508 if stream.status != StreamStatus::Enabled {
509 continue;
510 }
511 if stream.config.events_supported.is_empty()
513 || stream
514 .config
515 .events_supported
516 .iter()
517 .any(|e| e == &event.event_type)
518 {
519 stream.events.push(event.clone());
520 }
521 }
522 }
523
524 pub async fn active_stream_count(&self) -> usize {
526 self.streams
527 .read()
528 .await
529 .values()
530 .filter(|s| s.status == StreamStatus::Enabled)
531 .count()
532 }
533}
534
535pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
539
540pub struct CaepReceiver {
542 handlers: Arc<RwLock<HashMap<String, Vec<EventHandler>>>>,
543 received_jtis: Arc<RwLock<std::collections::HashSet<String>>>,
544}
545
546impl CaepReceiver {
547 pub fn new() -> Self {
548 Self {
549 handlers: Arc::new(RwLock::new(HashMap::new())),
550 received_jtis: Arc::new(RwLock::new(std::collections::HashSet::new())),
551 }
552 }
553
554 pub async fn on_event(&self, event_type: &str, handler: EventHandler) {
556 self.handlers
557 .write()
558 .await
559 .entry(event_type.to_string())
560 .or_default()
561 .push(handler);
562 }
563
564 pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
568 {
570 let mut jtis = self.received_jtis.write().await;
571 if !jtis.insert(event.jti.clone()) {
572 return Ok(false); }
574 }
575
576 let handlers = self.handlers.read().await;
578 if let Some(handler_list) = handlers.get(&event.event_type) {
579 for handler in handler_list {
580 handler(event);
581 }
582 }
583
584 Ok(true)
585 }
586
587 pub async fn was_processed(&self, jti: &str) -> bool {
589 self.received_jtis.read().await.contains(jti)
590 }
591}
592
593impl Default for CaepReceiver {
594 fn default() -> Self {
595 Self::new()
596 }
597}
598
599#[cfg(test)]
600mod tests {
601 use super::*;
602
603 #[test]
606 fn test_subject_email_serialization() {
607 let sub = SubjectIdentifier::Email {
608 email: "user@example.com".to_string(),
609 };
610 let json = serde_json::to_value(&sub).unwrap();
611 assert_eq!(json["format"], "email");
612 assert_eq!(json["email"], "user@example.com");
613 }
614
615 #[test]
616 fn test_subject_iss_sub_serialization() {
617 let sub = SubjectIdentifier::IssSub {
618 iss: "https://issuer.example".to_string(),
619 sub: "user-123".to_string(),
620 };
621 let json = serde_json::to_value(&sub).unwrap();
622 assert_eq!(json["format"], "iss_sub");
623 }
624
625 #[test]
626 fn test_subject_session_id_serialization() {
627 let sub = SubjectIdentifier::SessionId {
628 session_id: "sess-001".to_string(),
629 iss: Some("https://issuer.example".to_string()),
630 };
631 let json = serde_json::to_value(&sub).unwrap();
632 assert_eq!(json["format"], "session_id");
633 assert_eq!(json["session_id"], "sess-001");
634 }
635
636 #[test]
637 fn test_subject_roundtrip() {
638 let sub = SubjectIdentifier::Opaque {
639 id: "opaque-id-42".to_string(),
640 };
641 let serialized = serde_json::to_string(&sub).unwrap();
642 let deserialized: SubjectIdentifier = serde_json::from_str(&serialized).unwrap();
643 assert_eq!(sub, deserialized);
644 }
645
646 #[test]
649 fn test_event_creation() {
650 let event = CaepEvent::new(
651 "https://issuer.example",
652 event_types::SESSION_REVOKED,
653 SubjectIdentifier::Email {
654 email: "user@x.com".to_string(),
655 },
656 );
657 assert!(!event.jti.is_empty());
658 assert!(event.iat > 0);
659 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
660 }
661
662 #[test]
663 fn test_event_builder_chain() {
664 let event = CaepEvent::new(
665 "https://issuer.example",
666 event_types::CREDENTIAL_CHANGE,
667 SubjectIdentifier::Email {
668 email: "u@x.com".to_string(),
669 },
670 )
671 .with_initiating_entity(EventReasonAdmin::Admin)
672 .with_reason_admin("Password reset")
673 .with_reason_user("Your password was reset by admin")
674 .with_property("change_type", serde_json::json!("revoke"));
675
676 assert_eq!(event.initiating_entity, Some(EventReasonAdmin::Admin));
677 assert_eq!(event.reason_admin.as_deref(), Some("Password reset"));
678 assert!(event.properties.contains_key("change_type"));
679 }
680
681 #[test]
682 fn test_event_to_set_claims() {
683 let event = CaepEvent::new(
684 "https://iss.example",
685 event_types::SESSION_REVOKED,
686 SubjectIdentifier::Email {
687 email: "u@x.com".to_string(),
688 },
689 )
690 .with_reason_admin("Policy violation");
691
692 let claims = event.to_set_claims();
693 assert_eq!(claims["iss"], "https://iss.example");
694 assert!(claims["events"][event_types::SESSION_REVOKED].is_object());
695 let ev = &claims["events"][event_types::SESSION_REVOKED];
696 assert!(ev["subject"].is_object());
697 assert_eq!(ev["reason_admin"]["en"], "Policy violation");
698 }
699
700 #[tokio::test]
703 async fn test_transmitter_create_stream() {
704 let tx = CaepTransmitter::new("https://issuer.example");
705 let config =
706 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
707 .audience("https://receiver.example")
708 .supports_event(event_types::SESSION_REVOKED)
709 .build();
710 let stream_id = tx.create_stream(config.clone()).await;
711 assert!(!stream_id.is_empty());
712 assert_eq!(tx.active_stream_count().await, 1);
713
714 let retrieved = tx.get_stream_config(&stream_id).await.unwrap();
715 assert_eq!(retrieved.iss, config.iss);
716 }
717
718 #[tokio::test]
719 async fn test_transmitter_stream_status() {
720 let tx = CaepTransmitter::new("https://iss.example");
721 let id = tx
722 .create_stream(StreamConfig::poll("https://iss.example", "").build())
723 .await;
724
725 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Enabled));
726
727 tx.set_stream_status(&id, StreamStatus::Paused)
728 .await
729 .unwrap();
730 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Paused));
731 assert_eq!(tx.active_stream_count().await, 0);
732 }
733
734 #[tokio::test]
735 async fn test_transmitter_delete_stream() {
736 let tx = CaepTransmitter::new("https://iss.example");
737 let id = tx.create_stream(StreamConfig::push("", "").build()).await;
738
739 assert!(tx.delete_stream(&id).await);
740 assert!(!tx.delete_stream(&id).await); assert_eq!(tx.active_stream_count().await, 0);
742 }
743
744 #[tokio::test]
745 async fn test_transmitter_emit_session_revoked() {
746 let tx = CaepTransmitter::new("https://iss.example");
747 let id = tx
748 .create_stream(
749 StreamConfig::poll("", "")
750 .supports_event(event_types::SESSION_REVOKED)
751 .build(),
752 )
753 .await;
754
755 let event = tx
756 .emit_session_revoked(
757 SubjectIdentifier::Email {
758 email: "u@x.com".to_string(),
759 },
760 Some("Security policy"),
761 )
762 .await
763 .unwrap();
764
765 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
766
767 let events = tx.poll_events(&id).await.unwrap();
768 assert_eq!(events.len(), 1);
769 assert_eq!(events[0].jti, event.jti);
770
771 let events2 = tx.poll_events(&id).await.unwrap();
773 assert!(events2.is_empty());
774 }
775
776 #[tokio::test]
777 async fn test_transmitter_event_filtering() {
778 let tx = CaepTransmitter::new("https://iss.example");
779
780 let id = tx
782 .create_stream(
783 StreamConfig::poll("", "")
784 .supports_event(event_types::SESSION_REVOKED)
785 .build(),
786 )
787 .await;
788
789 tx.emit_credential_change(
791 SubjectIdentifier::Email {
792 email: "u@x.com".to_string(),
793 },
794 ChangeType::Revoke,
795 )
796 .await
797 .unwrap();
798
799 let events = tx.poll_events(&id).await.unwrap();
800 assert!(events.is_empty());
801 }
802
803 #[tokio::test]
804 async fn test_transmitter_paused_stream_no_events() {
805 let tx = CaepTransmitter::new("https://iss.example");
806 let id = tx.create_stream(StreamConfig::poll("", "").build()).await;
807
808 tx.set_stream_status(&id, StreamStatus::Paused)
809 .await
810 .unwrap();
811
812 tx.emit_session_revoked(
813 SubjectIdentifier::Email {
814 email: "u@x.com".to_string(),
815 },
816 None,
817 )
818 .await
819 .unwrap();
820
821 assert!(tx.poll_events(&id).await.is_err());
823 }
824
825 #[tokio::test]
828 async fn test_receiver_process_event() {
829 let rx = CaepReceiver::new();
830 let called = Arc::new(std::sync::atomic::AtomicBool::new(false));
831 let called_clone = called.clone();
832
833 rx.on_event(
834 event_types::SESSION_REVOKED,
835 Arc::new(move |_event| {
836 called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
837 }),
838 )
839 .await;
840
841 let event = CaepEvent::new(
842 "https://iss.example",
843 event_types::SESSION_REVOKED,
844 SubjectIdentifier::Email {
845 email: "u@x.com".to_string(),
846 },
847 );
848
849 let processed = rx.process_event(&event).await.unwrap();
850 assert!(processed);
851 assert!(called.load(std::sync::atomic::Ordering::SeqCst));
852 }
853
854 #[test]
855 fn test_stream_config_builder() {
856 let config =
857 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
858 .audience("https://receiver.example")
859 .audiences(["https://backup.example"])
860 .supports_event(event_types::SESSION_REVOKED)
861 .events_supported([event_types::CREDENTIAL_CHANGE])
862 .build();
863
864 assert_eq!(config.delivery_method, DeliveryMethod::Poll);
865 assert_eq!(config.aud.len(), 2);
866 assert_eq!(config.events_supported.len(), 2);
867 }
868
869 #[tokio::test]
870 async fn test_receiver_deduplication() {
871 let rx = CaepReceiver::new();
872 let event = CaepEvent::new(
873 "https://iss.example",
874 event_types::CREDENTIAL_CHANGE,
875 SubjectIdentifier::Opaque {
876 id: "x".to_string(),
877 },
878 );
879
880 let first = rx.process_event(&event).await.unwrap();
881 assert!(first);
882
883 let second = rx.process_event(&event).await.unwrap();
884 assert!(!second); assert!(rx.was_processed(&event.jti).await);
887 }
888
889 #[tokio::test]
890 async fn test_receiver_unhandled_event_type() {
891 let rx = CaepReceiver::new();
892 let event = CaepEvent::new(
893 "https://iss.example",
894 "custom:unknown-event",
895 SubjectIdentifier::Opaque {
896 id: "x".to_string(),
897 },
898 );
899 let processed = rx.process_event(&event).await.unwrap();
901 assert!(processed);
902 }
903
904 #[test]
907 fn test_delivery_method_serialization() {
908 assert_eq!(
909 serde_json::to_string(&DeliveryMethod::Push).unwrap(),
910 r#""push""#
911 );
912 assert_eq!(
913 serde_json::to_string(&DeliveryMethod::Poll).unwrap(),
914 r#""poll""#
915 );
916 }
917}