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(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
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// ── CAEP Event ──────────────────────────────────────────────────────
88
89/// The reason/initiating entity for a CAEP event.
90#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
91#[serde(rename_all = "lowercase")]
92pub enum EventReasonAdmin {
93    /// Policy-driven.
94    Policy,
95    /// Admin-initiated.
96    Admin,
97    /// User-initiated.
98    User,
99}
100
101/// Change type for credential/compliance events.
102#[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/// A CAEP event (carried as a Security Event Token — SET).
112#[derive(Debug, Clone, Serialize, Deserialize)]
113pub struct CaepEvent {
114    /// Unique event ID (jti).
115    pub jti: String,
116    /// Issuer.
117    pub iss: String,
118    /// Issued-at (Unix timestamp).
119    pub iat: u64,
120    /// Event type URI.
121    pub event_type: String,
122    /// Subject identifier.
123    pub subject: SubjectIdentifier,
124    /// Initiating entity.
125    #[serde(default)]
126    pub initiating_entity: Option<EventReasonAdmin>,
127    /// Reason string for the event.
128    #[serde(default)]
129    pub reason_admin: Option<String>,
130    /// Reason string shown to the user.
131    #[serde(default)]
132    pub reason_user: Option<String>,
133    /// Additional event-specific claims.
134    #[serde(default)]
135    pub properties: HashMap<String, serde_json::Value>,
136}
137
138impl CaepEvent {
139    /// Build a new CAEP event with generated ID and timestamp.
140    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    /// Set the initiating entity.
160    pub fn with_initiating_entity(mut self, entity: EventReasonAdmin) -> Self {
161        self.initiating_entity = Some(entity);
162        self
163    }
164
165    /// Set the admin reason.
166    pub fn with_reason_admin(mut self, reason: &str) -> Self {
167        self.reason_admin = Some(reason.to_string());
168        self
169    }
170
171    /// Set the user-facing reason.
172    pub fn with_reason_user(mut self, reason: &str) -> Self {
173        self.reason_user = Some(reason.to_string());
174        self
175    }
176
177    /// Add an event-specific property.
178    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    /// Encode the event as a SET (Security Event Token) claims payload.
184    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            // Hand-encode instead of `serde_json::to_value(entity).unwrap()`: this
191            // method returns `Value` (not `Result`), and a fallible conversion
192            // here would need a breaking API change. Encoding the fieldless enum
193            // directly removes the failure mode entirely rather than assuming it
194            // away.
195            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// ── Stream configuration (SSE §6) ──────────────────────────────────
223
224/// SSE stream delivery method.
225#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
226#[serde(rename_all = "lowercase")]
227pub enum DeliveryMethod {
228    /// Push via HTTP POST.
229    Push,
230    /// Poll (receiver calls GET).
231    Poll,
232}
233
234/// SSE stream configuration.
235#[derive(Debug, Clone, Serialize, Deserialize)]
236pub struct StreamConfig {
237    /// Issuer URL.
238    pub iss: String,
239    /// Audience for events on this stream.
240    pub aud: Vec<String>,
241    /// Supported event types.
242    pub events_supported: Vec<String>,
243    /// Delivery method.
244    pub delivery_method: DeliveryMethod,
245    /// Endpoint URL (push: receiver's endpoint; poll: transmitter's endpoint).
246    pub endpoint_url: String,
247}
248
249impl StreamConfig {
250    /// Create a builder for an event stream configuration.
251    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    /// Create a poll-based stream configuration builder.
262    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    /// Create a push-based stream configuration builder.
267    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
272/// Builder for CAEP stream configuration.
273pub 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    /// Add a single audience to the stream.
283    pub fn audience(mut self, audience: impl Into<String>) -> Self {
284        self.aud.push(audience.into());
285        self
286    }
287
288    /// Add multiple audiences to the stream.
289    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    /// Add a supported event type to the stream.
299    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    /// Add multiple supported event types.
305    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    /// Set the delivery method.
316    pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
317        self.delivery_method = delivery_method;
318        self
319    }
320
321    /// Build the stream configuration.
322    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/// Stream status.
334#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
335#[serde(rename_all = "lowercase")]
336pub enum StreamStatus {
337    Enabled,
338    Paused,
339    Disabled,
340}
341
342// ── Event transmitter ───────────────────────────────────────────────
343
344/// A registered event stream with its buffered events.
345struct EventStream {
346    config: StreamConfig,
347    status: StreamStatus,
348    events: Vec<CaepEvent>,
349}
350
351/// CAEP event transmitter — manages streams and dispatches events.
352pub 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    /// Register a new event stream. Returns the stream ID.
366    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    /// Get stream configuration.
380    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    /// Update stream status.
389    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    /// Get stream status.
399    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    /// Delete a stream.
408    pub async fn delete_stream(&self, stream_id: &str) -> bool {
409        self.streams.write().await.remove(stream_id).is_some()
410    }
411
412    /// Emit a session-revoked event to all enabled streams.
413    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    /// Emit a credential-change event.
427    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    /// Emit a device-compliance-change event.
442    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    /// Emit a token-claims-change event.
456    ///
457    /// Signals that one or more claims in a previously issued token have changed.
458    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    /// Emit an assurance-level-change event.
472    ///
473    /// Signals that the authentication assurance level for a subject has changed.
474    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    /// Poll events for a stream (for pull-based delivery).
490    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    /// Dispatch an event to all enabled streams.
505    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            // Check if this stream accepts the event type
512            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    /// Count active (enabled) streams.
525    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
535// ── Event receiver ──────────────────────────────────────────────────
536
537/// Callback type for handling received CAEP events.
538pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
539
540/// CAEP event receiver — processes incoming events.
541pub 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    /// Register a handler for a specific event type.
555    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    /// Process a received CAEP event.
565    ///
566    /// Deduplicates by jti and invokes registered handlers.
567    pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
568        // Deduplicate
569        {
570            let mut jtis = self.received_jtis.write().await;
571            if !jtis.insert(event.jti.clone()) {
572                return Ok(false); // Already processed
573            }
574        }
575
576        // Invoke handlers
577        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    /// Check if an event was already processed.
588    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    // ── Subject identifiers ─────────────────────────────────────
604
605    #[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    // ── CaepEvent construction ──────────────────────────────────
647
648    #[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    // ── Transmitter ─────────────────────────────────────────────
701
702    #[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); // second delete → false
741        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        // Second poll should be empty (events consumed)
772        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        // Stream only wants session-revoked events
781        let id = tx
782            .create_stream(
783                StreamConfig::poll("", "")
784                    .supports_event(event_types::SESSION_REVOKED)
785                    .build(),
786            )
787            .await;
788
789        // Emit a credential_change event — should NOT appear
790        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        // Paused streams can't be polled
822        assert!(tx.poll_events(&id).await.is_err());
823    }
824
825    // ── Receiver ────────────────────────────────────────────────
826
827    #[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); // duplicate
885
886        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        // Should succeed even without a registered handler
900        let processed = rx.process_event(&event).await.unwrap();
901        assert!(processed);
902    }
903
904    // ── Delivery method serialization ───────────────────────────
905
906    #[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}