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            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// ── Stream configuration (SSE §6) ──────────────────────────────────
214
215/// SSE stream delivery method.
216#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
217#[serde(rename_all = "lowercase")]
218pub enum DeliveryMethod {
219    /// Push via HTTP POST.
220    Push,
221    /// Poll (receiver calls GET).
222    Poll,
223}
224
225/// SSE stream configuration.
226#[derive(Debug, Clone, Serialize, Deserialize)]
227pub struct StreamConfig {
228    /// Issuer URL.
229    pub iss: String,
230    /// Audience for events on this stream.
231    pub aud: Vec<String>,
232    /// Supported event types.
233    pub events_supported: Vec<String>,
234    /// Delivery method.
235    pub delivery_method: DeliveryMethod,
236    /// Endpoint URL (push: receiver's endpoint; poll: transmitter's endpoint).
237    pub endpoint_url: String,
238}
239
240impl StreamConfig {
241    /// Create a builder for an event stream configuration.
242    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    /// Create a poll-based stream configuration builder.
253    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    /// Create a push-based stream configuration builder.
258    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
263/// Builder for CAEP stream configuration.
264pub 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    /// Add a single audience to the stream.
274    pub fn audience(mut self, audience: impl Into<String>) -> Self {
275        self.aud.push(audience.into());
276        self
277    }
278
279    /// Add multiple audiences to the stream.
280    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    /// Add a supported event type to the stream.
290    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    /// Add multiple supported event types.
296    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    /// Set the delivery method.
307    pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
308        self.delivery_method = delivery_method;
309        self
310    }
311
312    /// Build the stream configuration.
313    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/// Stream status.
325#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
326#[serde(rename_all = "lowercase")]
327pub enum StreamStatus {
328    Enabled,
329    Paused,
330    Disabled,
331}
332
333// ── Event transmitter ───────────────────────────────────────────────
334
335/// A registered event stream with its buffered events.
336struct EventStream {
337    config: StreamConfig,
338    status: StreamStatus,
339    events: Vec<CaepEvent>,
340}
341
342/// CAEP event transmitter — manages streams and dispatches events.
343pub 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    /// Register a new event stream. Returns the stream ID.
357    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    /// Get stream configuration.
371    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    /// Update stream status.
380    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    /// Get stream status.
390    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    /// Delete a stream.
399    pub async fn delete_stream(&self, stream_id: &str) -> bool {
400        self.streams.write().await.remove(stream_id).is_some()
401    }
402
403    /// Emit a session-revoked event to all enabled streams.
404    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    /// Emit a credential-change event.
418    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    /// Emit a device-compliance-change event.
434    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    /// Emit a token-claims-change event.
448    ///
449    /// Signals that one or more claims in a previously issued token have changed.
450    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    /// Emit an assurance-level-change event.
465    ///
466    /// Signals that the authentication assurance level for a subject has changed.
467    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    /// Poll events for a stream (for pull-based delivery).
483    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    /// Dispatch an event to all enabled streams.
498    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            // Check if this stream accepts the event type
505            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    /// Count active (enabled) streams.
518    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
528// ── Event receiver ──────────────────────────────────────────────────
529
530/// Callback type for handling received CAEP events.
531pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
532
533/// CAEP event receiver — processes incoming events.
534pub 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    /// Register a handler for a specific event type.
548    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    /// Process a received CAEP event.
558    ///
559    /// Deduplicates by jti and invokes registered handlers.
560    pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
561        // Deduplicate
562        {
563            let mut jtis = self.received_jtis.write().await;
564            if !jtis.insert(event.jti.clone()) {
565                return Ok(false); // Already processed
566            }
567        }
568
569        // Invoke handlers
570        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    /// Check if an event was already processed.
581    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    // ── Subject identifiers ─────────────────────────────────────
597
598    #[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    // ── CaepEvent construction ──────────────────────────────────
640
641    #[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    // ── Transmitter ─────────────────────────────────────────────
694
695    #[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); // second delete → false
734        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        // Second poll should be empty (events consumed)
765        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        // Stream only wants session-revoked events
774        let id = tx
775            .create_stream(
776                StreamConfig::poll("", "")
777                    .supports_event(event_types::SESSION_REVOKED)
778                    .build(),
779            )
780            .await;
781
782        // Emit a credential_change event — should NOT appear
783        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        // Paused streams can't be polled
815        assert!(tx.poll_events(&id).await.is_err());
816    }
817
818    // ── Receiver ────────────────────────────────────────────────
819
820    #[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); // duplicate
878
879        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        // Should succeed even without a registered handler
893        let processed = rx.process_event(&event).await.unwrap();
894        assert!(processed);
895    }
896
897    // ── Delivery method serialization ───────────────────────────
898
899    #[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}