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