Skip to main content

auth_framework/protocols/
caep.rs

1//! CAEP (Continuous Access Evaluation Protocol) implementation.
2//!
3//! Implements the Shared Signals and Events (SSE) Framework with CAEP event types
4//! for continuous access evaluation, session revocation, and compliance signalling.
5//!
6//! # References
7//!
8//! - [CAEP spec](https://openid.net/specs/openid-caep-specification-1_0.html)
9//! - [SSE Framework](https://openid.net/specs/openid-sse-framework-1_0.html)
10//! - [SET (Security Event Token) RFC 8417](https://www.rfc-editor.org/rfc/rfc8417)
11
12use 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
20// ── Event types (CAEP §3) ───────────────────────────────────────────
21
22/// Well-known CAEP event type URIs.
23pub 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// ── Subject identifiers (SSE §3) ───────────────────────────────────
37
38/// Subject identifier formats per the SSE Framework.
39#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
40#[serde(tag = "format")]
41pub enum SubjectIdentifier {
42    /// Email-based subject.
43    #[serde(rename = "email")]
44    Email { email: String },
45    /// Issuer + subject pair.
46    #[serde(rename = "iss_sub")]
47    IssSub { iss: String, sub: String },
48    /// Opaque identifier.
49    #[serde(rename = "opaque")]
50    Opaque { id: String },
51    /// Phone number (+E.164).
52    #[serde(rename = "phone_number")]
53    PhoneNumber { phone_number: String },
54    /// Session ID.
55    #[serde(rename = "session_id")]
56    SessionId {
57        session_id: String,
58        #[serde(default)]
59        iss: Option<String>,
60    },
61}
62
63// ── CAEP Event ──────────────────────────────────────────────────────
64
65/// The reason/initiating entity for a CAEP event.
66#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
67#[serde(rename_all = "lowercase")]
68pub enum EventReasonAdmin {
69    /// Policy-driven.
70    Policy,
71    /// Admin-initiated.
72    Admin,
73    /// User-initiated.
74    User,
75}
76
77/// Change type for credential/compliance events.
78#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
79#[serde(rename_all = "snake_case")]
80pub enum ChangeType {
81    Create,
82    Revoke,
83    Update,
84    Delete,
85}
86
87/// A CAEP event (carried as a Security Event Token — SET).
88#[derive(Debug, Clone, Serialize, Deserialize)]
89pub struct CaepEvent {
90    /// Unique event ID (jti).
91    pub jti: String,
92    /// Issuer.
93    pub iss: String,
94    /// Issued-at (Unix timestamp).
95    pub iat: u64,
96    /// Event type URI.
97    pub event_type: String,
98    /// Subject identifier.
99    pub subject: SubjectIdentifier,
100    /// Initiating entity.
101    #[serde(default)]
102    pub initiating_entity: Option<EventReasonAdmin>,
103    /// Reason string for the event.
104    #[serde(default)]
105    pub reason_admin: Option<String>,
106    /// Reason string shown to the user.
107    #[serde(default)]
108    pub reason_user: Option<String>,
109    /// Additional event-specific claims.
110    #[serde(default)]
111    pub properties: HashMap<String, serde_json::Value>,
112}
113
114impl CaepEvent {
115    /// Build a new CAEP event with generated ID and timestamp.
116    pub fn new(iss: &str, event_type: &str, subject: SubjectIdentifier) -> Self {
117        let now = SystemTime::now()
118            .duration_since(UNIX_EPOCH)
119            .unwrap_or_default()
120            .as_secs();
121
122        Self {
123            jti: Uuid::new_v4().to_string(),
124            iss: iss.to_string(),
125            iat: now,
126            event_type: event_type.to_string(),
127            subject,
128            initiating_entity: None,
129            reason_admin: None,
130            reason_user: None,
131            properties: HashMap::new(),
132        }
133    }
134
135    /// Set the initiating entity.
136    pub fn with_initiating_entity(mut self, entity: EventReasonAdmin) -> Self {
137        self.initiating_entity = Some(entity);
138        self
139    }
140
141    /// Set the admin reason.
142    pub fn with_reason_admin(mut self, reason: &str) -> Self {
143        self.reason_admin = Some(reason.to_string());
144        self
145    }
146
147    /// Set the user-facing reason.
148    pub fn with_reason_user(mut self, reason: &str) -> Self {
149        self.reason_user = Some(reason.to_string());
150        self
151    }
152
153    /// Add an event-specific property.
154    pub fn with_property(mut self, key: &str, value: serde_json::Value) -> Self {
155        self.properties.insert(key.to_string(), value);
156        self
157    }
158
159    /// Encode the event as a SET (Security Event Token) claims payload.
160    pub fn to_set_claims(&self) -> serde_json::Value {
161        let mut events: HashMap<String, serde_json::Value> = HashMap::new();
162        let mut event_body = serde_json::json!({
163            "subject": self.subject,
164        });
165        if let Some(ref entity) = self.initiating_entity {
166            // Hand-encode instead of `serde_json::to_value(entity).unwrap()`: this
167            // method returns `Value` (not `Result`), and a fallible conversion
168            // here would need a breaking API change. Encoding the fieldless enum
169            // directly removes the failure mode entirely rather than assuming it
170            // away.
171            let encoded = match entity {
172                EventReasonAdmin::Policy => "policy",
173                EventReasonAdmin::Admin => "admin",
174                EventReasonAdmin::User => "user",
175            };
176            event_body["initiating_entity"] = serde_json::Value::String(encoded.to_string());
177        }
178        if let Some(ref r) = self.reason_admin {
179            event_body["reason_admin"] = serde_json::json!({"en": r});
180        }
181        if let Some(ref r) = self.reason_user {
182            event_body["reason_user"] = serde_json::json!({"en": r});
183        }
184        for (k, v) in &self.properties {
185            event_body[k] = v.clone();
186        }
187        events.insert(self.event_type.clone(), event_body);
188
189        serde_json::json!({
190            "jti": self.jti,
191            "iss": self.iss,
192            "iat": self.iat,
193            "events": events,
194        })
195    }
196}
197
198// ── Stream configuration (SSE §6) ──────────────────────────────────
199
200/// SSE stream delivery method.
201#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
202#[serde(rename_all = "lowercase")]
203pub enum DeliveryMethod {
204    /// Push via HTTP POST.
205    Push,
206    /// Poll (receiver calls GET).
207    Poll,
208}
209
210/// SSE stream configuration.
211#[derive(Debug, Clone, Serialize, Deserialize)]
212pub struct StreamConfig {
213    /// Issuer URL.
214    pub iss: String,
215    /// Audience for events on this stream.
216    pub aud: Vec<String>,
217    /// Supported event types.
218    pub events_supported: Vec<String>,
219    /// Delivery method.
220    pub delivery_method: DeliveryMethod,
221    /// Endpoint URL (push: receiver's endpoint; poll: transmitter's endpoint).
222    pub endpoint_url: String,
223}
224
225impl StreamConfig {
226    /// Create a builder for an event stream configuration.
227    pub fn builder(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
228        StreamConfigBuilder {
229            iss: iss.into(),
230            aud: Vec::new(),
231            events_supported: Vec::new(),
232            delivery_method: DeliveryMethod::Push,
233            endpoint_url: endpoint_url.into(),
234        }
235    }
236
237    /// Create a poll-based stream configuration builder.
238    pub fn poll(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
239        Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Poll)
240    }
241
242    /// Create a push-based stream configuration builder.
243    pub fn push(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
244        Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Push)
245    }
246}
247
248/// Builder for CAEP stream configuration.
249pub struct StreamConfigBuilder {
250    iss: String,
251    aud: Vec<String>,
252    events_supported: Vec<String>,
253    delivery_method: DeliveryMethod,
254    endpoint_url: String,
255}
256
257impl StreamConfigBuilder {
258    /// Add a single audience to the stream.
259    pub fn audience(mut self, audience: impl Into<String>) -> Self {
260        self.aud.push(audience.into());
261        self
262    }
263
264    /// Add multiple audiences to the stream.
265    pub fn audiences<I, S>(mut self, audiences: I) -> Self
266    where
267        I: IntoIterator<Item = S>,
268        S: Into<String>,
269    {
270        self.aud.extend(audiences.into_iter().map(Into::into));
271        self
272    }
273
274    /// Add a supported event type to the stream.
275    pub fn supports_event(mut self, event_type: impl Into<String>) -> Self {
276        self.events_supported.push(event_type.into());
277        self
278    }
279
280    /// Add multiple supported event types.
281    pub fn events_supported<I, S>(mut self, events: I) -> Self
282    where
283        I: IntoIterator<Item = S>,
284        S: Into<String>,
285    {
286        self.events_supported
287            .extend(events.into_iter().map(Into::into));
288        self
289    }
290
291    /// Set the delivery method.
292    pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
293        self.delivery_method = delivery_method;
294        self
295    }
296
297    /// Build the stream configuration.
298    pub fn build(self) -> StreamConfig {
299        StreamConfig {
300            iss: self.iss,
301            aud: self.aud,
302            events_supported: self.events_supported,
303            delivery_method: self.delivery_method,
304            endpoint_url: self.endpoint_url,
305        }
306    }
307}
308
309/// Stream status.
310#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
311#[serde(rename_all = "lowercase")]
312pub enum StreamStatus {
313    Enabled,
314    Paused,
315    Disabled,
316}
317
318// ── Event transmitter ───────────────────────────────────────────────
319
320/// A registered event stream with its buffered events.
321struct EventStream {
322    config: StreamConfig,
323    status: StreamStatus,
324    events: Vec<CaepEvent>,
325}
326
327/// CAEP event transmitter — manages streams and dispatches events.
328pub struct CaepTransmitter {
329    issuer: String,
330    streams: Arc<RwLock<HashMap<String, EventStream>>>,
331}
332
333impl CaepTransmitter {
334    pub fn new(issuer: &str) -> Self {
335        Self {
336            issuer: issuer.to_string(),
337            streams: Arc::new(RwLock::new(HashMap::new())),
338        }
339    }
340
341    /// Register a new event stream. Returns the stream ID.
342    pub async fn create_stream(&self, config: StreamConfig) -> String {
343        let stream_id = Uuid::new_v4().to_string();
344        self.streams.write().await.insert(
345            stream_id.clone(),
346            EventStream {
347                config,
348                status: StreamStatus::Enabled,
349                events: Vec::new(),
350            },
351        );
352        stream_id
353    }
354
355    /// Get stream configuration.
356    pub async fn get_stream_config(&self, stream_id: &str) -> Option<StreamConfig> {
357        self.streams
358            .read()
359            .await
360            .get(stream_id)
361            .map(|s| s.config.clone())
362    }
363
364    /// Update stream status.
365    pub async fn set_stream_status(&self, stream_id: &str, status: StreamStatus) -> Result<()> {
366        let mut streams = self.streams.write().await;
367        let stream = streams
368            .get_mut(stream_id)
369            .ok_or_else(|| AuthError::validation("Stream not found"))?;
370        stream.status = status;
371        Ok(())
372    }
373
374    /// Get stream status.
375    pub async fn get_stream_status(&self, stream_id: &str) -> Option<StreamStatus> {
376        self.streams
377            .read()
378            .await
379            .get(stream_id)
380            .map(|s| s.status.clone())
381    }
382
383    /// Delete a stream.
384    pub async fn delete_stream(&self, stream_id: &str) -> bool {
385        self.streams.write().await.remove(stream_id).is_some()
386    }
387
388    /// Emit a session-revoked event to all enabled streams.
389    pub async fn emit_session_revoked(
390        &self,
391        subject: SubjectIdentifier,
392        reason: Option<&str>,
393    ) -> Result<CaepEvent> {
394        let mut event = CaepEvent::new(&self.issuer, event_types::SESSION_REVOKED, subject);
395        if let Some(r) = reason {
396            event = event.with_reason_admin(r);
397        }
398        self.dispatch_event(&event).await;
399        Ok(event)
400    }
401
402    /// Emit a credential-change event.
403    pub async fn emit_credential_change(
404        &self,
405        subject: SubjectIdentifier,
406        change_type: ChangeType,
407    ) -> Result<CaepEvent> {
408        let change_type_value = serde_json::to_value(&change_type).map_err(|e| {
409            AuthError::internal(format!("Failed to serialize CAEP change_type: {e}"))
410        })?;
411        let event = CaepEvent::new(&self.issuer, event_types::CREDENTIAL_CHANGE, subject)
412            .with_property("change_type", change_type_value);
413        self.dispatch_event(&event).await;
414        Ok(event)
415    }
416
417    /// Emit a device-compliance-change event.
418    pub async fn emit_device_compliance_change(
419        &self,
420        subject: SubjectIdentifier,
421        previous_status: &str,
422        current_status: &str,
423    ) -> Result<CaepEvent> {
424        let event = CaepEvent::new(&self.issuer, event_types::DEVICE_COMPLIANCE_CHANGE, subject)
425            .with_property("previous_status", serde_json::json!(previous_status))
426            .with_property("current_status", serde_json::json!(current_status));
427        self.dispatch_event(&event).await;
428        Ok(event)
429    }
430
431    /// Emit a token-claims-change event.
432    ///
433    /// Signals that one or more claims in a previously issued token have changed.
434    pub async fn emit_token_claims_change(
435        &self,
436        subject: SubjectIdentifier,
437        claims: HashMap<String, serde_json::Value>,
438    ) -> Result<CaepEvent> {
439        let mut event = CaepEvent::new(&self.issuer, event_types::TOKEN_CLAIMS_CHANGE, subject);
440        let claims_value = serde_json::to_value(&claims)
441            .map_err(|e| AuthError::internal(format!("Failed to serialize CAEP claims: {e}")))?;
442        event = event.with_property("claims", claims_value);
443        self.dispatch_event(&event).await;
444        Ok(event)
445    }
446
447    /// Emit an assurance-level-change event.
448    ///
449    /// Signals that the authentication assurance level for a subject has changed.
450    pub async fn emit_assurance_level_change(
451        &self,
452        subject: SubjectIdentifier,
453        current_level: &str,
454        previous_level: &str,
455        change_direction: &str,
456    ) -> Result<CaepEvent> {
457        let event = CaepEvent::new(&self.issuer, event_types::ASSURANCE_LEVEL_CHANGE, subject)
458            .with_property("current_level", serde_json::json!(current_level))
459            .with_property("previous_level", serde_json::json!(previous_level))
460            .with_property("change_direction", serde_json::json!(change_direction));
461        self.dispatch_event(&event).await;
462        Ok(event)
463    }
464
465    /// Poll events for a stream (for pull-based delivery).
466    pub async fn poll_events(&self, stream_id: &str) -> Result<Vec<CaepEvent>> {
467        let mut streams = self.streams.write().await;
468        let stream = streams
469            .get_mut(stream_id)
470            .ok_or_else(|| AuthError::validation("Stream not found"))?;
471
472        if stream.status != StreamStatus::Enabled {
473            return Err(AuthError::validation("Stream is not enabled"));
474        }
475
476        let events = std::mem::take(&mut stream.events);
477        Ok(events)
478    }
479
480    /// Dispatch an event to all enabled streams.
481    async fn dispatch_event(&self, event: &CaepEvent) {
482        let mut streams = self.streams.write().await;
483        for stream in streams.values_mut() {
484            if stream.status != StreamStatus::Enabled {
485                continue;
486            }
487            // Check if this stream accepts the event type
488            if stream.config.events_supported.is_empty()
489                || stream
490                    .config
491                    .events_supported
492                    .iter()
493                    .any(|e| e == &event.event_type)
494            {
495                stream.events.push(event.clone());
496            }
497        }
498    }
499
500    /// Count active (enabled) streams.
501    pub async fn active_stream_count(&self) -> usize {
502        self.streams
503            .read()
504            .await
505            .values()
506            .filter(|s| s.status == StreamStatus::Enabled)
507            .count()
508    }
509}
510
511// ── Event receiver ──────────────────────────────────────────────────
512
513/// Callback type for handling received CAEP events.
514pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
515
516/// CAEP event receiver — processes incoming events.
517pub struct CaepReceiver {
518    handlers: Arc<RwLock<HashMap<String, Vec<EventHandler>>>>,
519    received_jtis: Arc<RwLock<std::collections::HashSet<String>>>,
520}
521
522impl CaepReceiver {
523    pub fn new() -> Self {
524        Self {
525            handlers: Arc::new(RwLock::new(HashMap::new())),
526            received_jtis: Arc::new(RwLock::new(std::collections::HashSet::new())),
527        }
528    }
529
530    /// Register a handler for a specific event type.
531    pub async fn on_event(&self, event_type: &str, handler: EventHandler) {
532        self.handlers
533            .write()
534            .await
535            .entry(event_type.to_string())
536            .or_default()
537            .push(handler);
538    }
539
540    /// Process a received CAEP event.
541    ///
542    /// Deduplicates by jti and invokes registered handlers.
543    pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
544        // Deduplicate
545        {
546            let mut jtis = self.received_jtis.write().await;
547            if !jtis.insert(event.jti.clone()) {
548                return Ok(false); // Already processed
549            }
550        }
551
552        // Invoke handlers
553        let handlers = self.handlers.read().await;
554        if let Some(handler_list) = handlers.get(&event.event_type) {
555            for handler in handler_list {
556                handler(event);
557            }
558        }
559
560        Ok(true)
561    }
562
563    /// Check if an event was already processed.
564    pub async fn was_processed(&self, jti: &str) -> bool {
565        self.received_jtis.read().await.contains(jti)
566    }
567}
568
569impl Default for CaepReceiver {
570    fn default() -> Self {
571        Self::new()
572    }
573}
574
575#[cfg(test)]
576mod tests {
577    use super::*;
578
579    // ── Subject identifiers ─────────────────────────────────────
580
581    #[test]
582    fn test_subject_email_serialization() {
583        let sub = SubjectIdentifier::Email {
584            email: "user@example.com".to_string(),
585        };
586        let json = serde_json::to_value(&sub).unwrap();
587        assert_eq!(json["format"], "email");
588        assert_eq!(json["email"], "user@example.com");
589    }
590
591    #[test]
592    fn test_subject_iss_sub_serialization() {
593        let sub = SubjectIdentifier::IssSub {
594            iss: "https://issuer.example".to_string(),
595            sub: "user-123".to_string(),
596        };
597        let json = serde_json::to_value(&sub).unwrap();
598        assert_eq!(json["format"], "iss_sub");
599    }
600
601    #[test]
602    fn test_subject_session_id_serialization() {
603        let sub = SubjectIdentifier::SessionId {
604            session_id: "sess-001".to_string(),
605            iss: Some("https://issuer.example".to_string()),
606        };
607        let json = serde_json::to_value(&sub).unwrap();
608        assert_eq!(json["format"], "session_id");
609        assert_eq!(json["session_id"], "sess-001");
610    }
611
612    #[test]
613    fn test_subject_roundtrip() {
614        let sub = SubjectIdentifier::Opaque {
615            id: "opaque-id-42".to_string(),
616        };
617        let serialized = serde_json::to_string(&sub).unwrap();
618        let deserialized: SubjectIdentifier = serde_json::from_str(&serialized).unwrap();
619        assert_eq!(sub, deserialized);
620    }
621
622    // ── CaepEvent construction ──────────────────────────────────
623
624    #[test]
625    fn test_event_creation() {
626        let event = CaepEvent::new(
627            "https://issuer.example",
628            event_types::SESSION_REVOKED,
629            SubjectIdentifier::Email {
630                email: "user@x.com".to_string(),
631            },
632        );
633        assert!(!event.jti.is_empty());
634        assert!(event.iat > 0);
635        assert_eq!(event.event_type, event_types::SESSION_REVOKED);
636    }
637
638    #[test]
639    fn test_event_builder_chain() {
640        let event = CaepEvent::new(
641            "https://issuer.example",
642            event_types::CREDENTIAL_CHANGE,
643            SubjectIdentifier::Email {
644                email: "u@x.com".to_string(),
645            },
646        )
647        .with_initiating_entity(EventReasonAdmin::Admin)
648        .with_reason_admin("Password reset")
649        .with_reason_user("Your password was reset by admin")
650        .with_property("change_type", serde_json::json!("revoke"));
651
652        assert_eq!(event.initiating_entity, Some(EventReasonAdmin::Admin));
653        assert_eq!(event.reason_admin.as_deref(), Some("Password reset"));
654        assert!(event.properties.contains_key("change_type"));
655    }
656
657    #[test]
658    fn test_event_to_set_claims() {
659        let event = CaepEvent::new(
660            "https://iss.example",
661            event_types::SESSION_REVOKED,
662            SubjectIdentifier::Email {
663                email: "u@x.com".to_string(),
664            },
665        )
666        .with_reason_admin("Policy violation");
667
668        let claims = event.to_set_claims();
669        assert_eq!(claims["iss"], "https://iss.example");
670        assert!(claims["events"][event_types::SESSION_REVOKED].is_object());
671        let ev = &claims["events"][event_types::SESSION_REVOKED];
672        assert!(ev["subject"].is_object());
673        assert_eq!(ev["reason_admin"]["en"], "Policy violation");
674    }
675
676    // ── Transmitter ─────────────────────────────────────────────
677
678    #[tokio::test]
679    async fn test_transmitter_create_stream() {
680        let tx = CaepTransmitter::new("https://issuer.example");
681        let config =
682            StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
683                .audience("https://receiver.example")
684                .supports_event(event_types::SESSION_REVOKED)
685                .build();
686        let stream_id = tx.create_stream(config.clone()).await;
687        assert!(!stream_id.is_empty());
688        assert_eq!(tx.active_stream_count().await, 1);
689
690        let retrieved = tx.get_stream_config(&stream_id).await.unwrap();
691        assert_eq!(retrieved.iss, config.iss);
692    }
693
694    #[tokio::test]
695    async fn test_transmitter_stream_status() {
696        let tx = CaepTransmitter::new("https://iss.example");
697        let id = tx
698            .create_stream(StreamConfig::poll("https://iss.example", "").build())
699            .await;
700
701        assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Enabled));
702
703        tx.set_stream_status(&id, StreamStatus::Paused)
704            .await
705            .unwrap();
706        assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Paused));
707        assert_eq!(tx.active_stream_count().await, 0);
708    }
709
710    #[tokio::test]
711    async fn test_transmitter_delete_stream() {
712        let tx = CaepTransmitter::new("https://iss.example");
713        let id = tx.create_stream(StreamConfig::push("", "").build()).await;
714
715        assert!(tx.delete_stream(&id).await);
716        assert!(!tx.delete_stream(&id).await); // second delete → false
717        assert_eq!(tx.active_stream_count().await, 0);
718    }
719
720    #[tokio::test]
721    async fn test_transmitter_emit_session_revoked() {
722        let tx = CaepTransmitter::new("https://iss.example");
723        let id = tx
724            .create_stream(
725                StreamConfig::poll("", "")
726                    .supports_event(event_types::SESSION_REVOKED)
727                    .build(),
728            )
729            .await;
730
731        let event = tx
732            .emit_session_revoked(
733                SubjectIdentifier::Email {
734                    email: "u@x.com".to_string(),
735                },
736                Some("Security policy"),
737            )
738            .await
739            .unwrap();
740
741        assert_eq!(event.event_type, event_types::SESSION_REVOKED);
742
743        let events = tx.poll_events(&id).await.unwrap();
744        assert_eq!(events.len(), 1);
745        assert_eq!(events[0].jti, event.jti);
746
747        // Second poll should be empty (events consumed)
748        let events2 = tx.poll_events(&id).await.unwrap();
749        assert!(events2.is_empty());
750    }
751
752    #[tokio::test]
753    async fn test_transmitter_event_filtering() {
754        let tx = CaepTransmitter::new("https://iss.example");
755
756        // Stream only wants session-revoked events
757        let id = tx
758            .create_stream(
759                StreamConfig::poll("", "")
760                    .supports_event(event_types::SESSION_REVOKED)
761                    .build(),
762            )
763            .await;
764
765        // Emit a credential_change event — should NOT appear
766        tx.emit_credential_change(
767            SubjectIdentifier::Email {
768                email: "u@x.com".to_string(),
769            },
770            ChangeType::Revoke,
771        )
772        .await
773        .unwrap();
774
775        let events = tx.poll_events(&id).await.unwrap();
776        assert!(events.is_empty());
777    }
778
779    #[tokio::test]
780    async fn test_transmitter_paused_stream_no_events() {
781        let tx = CaepTransmitter::new("https://iss.example");
782        let id = tx.create_stream(StreamConfig::poll("", "").build()).await;
783
784        tx.set_stream_status(&id, StreamStatus::Paused)
785            .await
786            .unwrap();
787
788        tx.emit_session_revoked(
789            SubjectIdentifier::Email {
790                email: "u@x.com".to_string(),
791            },
792            None,
793        )
794        .await
795        .unwrap();
796
797        // Paused streams can't be polled
798        assert!(tx.poll_events(&id).await.is_err());
799    }
800
801    // ── Receiver ────────────────────────────────────────────────
802
803    #[tokio::test]
804    async fn test_receiver_process_event() {
805        let rx = CaepReceiver::new();
806        let called = Arc::new(std::sync::atomic::AtomicBool::new(false));
807        let called_clone = called.clone();
808
809        rx.on_event(
810            event_types::SESSION_REVOKED,
811            Arc::new(move |_event| {
812                called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
813            }),
814        )
815        .await;
816
817        let event = CaepEvent::new(
818            "https://iss.example",
819            event_types::SESSION_REVOKED,
820            SubjectIdentifier::Email {
821                email: "u@x.com".to_string(),
822            },
823        );
824
825        let processed = rx.process_event(&event).await.unwrap();
826        assert!(processed);
827        assert!(called.load(std::sync::atomic::Ordering::SeqCst));
828    }
829
830    #[test]
831    fn test_stream_config_builder() {
832        let config =
833            StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
834                .audience("https://receiver.example")
835                .audiences(["https://backup.example"])
836                .supports_event(event_types::SESSION_REVOKED)
837                .events_supported([event_types::CREDENTIAL_CHANGE])
838                .build();
839
840        assert_eq!(config.delivery_method, DeliveryMethod::Poll);
841        assert_eq!(config.aud.len(), 2);
842        assert_eq!(config.events_supported.len(), 2);
843    }
844
845    #[tokio::test]
846    async fn test_receiver_deduplication() {
847        let rx = CaepReceiver::new();
848        let event = CaepEvent::new(
849            "https://iss.example",
850            event_types::CREDENTIAL_CHANGE,
851            SubjectIdentifier::Opaque {
852                id: "x".to_string(),
853            },
854        );
855
856        let first = rx.process_event(&event).await.unwrap();
857        assert!(first);
858
859        let second = rx.process_event(&event).await.unwrap();
860        assert!(!second); // duplicate
861
862        assert!(rx.was_processed(&event.jti).await);
863    }
864
865    #[tokio::test]
866    async fn test_receiver_unhandled_event_type() {
867        let rx = CaepReceiver::new();
868        let event = CaepEvent::new(
869            "https://iss.example",
870            "custom:unknown-event",
871            SubjectIdentifier::Opaque {
872                id: "x".to_string(),
873            },
874        );
875        // Should succeed even without a registered handler
876        let processed = rx.process_event(&event).await.unwrap();
877        assert!(processed);
878    }
879
880    // ── Delivery method serialization ───────────────────────────
881
882    #[test]
883    fn test_delivery_method_serialization() {
884        assert_eq!(
885            serde_json::to_string(&DeliveryMethod::Push).unwrap(),
886            r#""push""#
887        );
888        assert_eq!(
889            serde_json::to_string(&DeliveryMethod::Poll).unwrap(),
890            r#""poll""#
891        );
892    }
893}