1use crate::errors::{AuthError, Result};
13use serde::{Deserialize, Serialize};
14use std::collections::HashMap;
15use std::sync::Arc;
16use std::time::{SystemTime, UNIX_EPOCH};
17use tokio::sync::RwLock;
18use uuid::Uuid;
19
20pub mod event_types {
24 pub const SESSION_REVOKED: &str =
25 "https://schemas.openid.net/secevent/caep/event-type/session-revoked";
26 pub const TOKEN_CLAIMS_CHANGE: &str =
27 "https://schemas.openid.net/secevent/caep/event-type/token-claims-change";
28 pub const CREDENTIAL_CHANGE: &str =
29 "https://schemas.openid.net/secevent/caep/event-type/credential-change";
30 pub const ASSURANCE_LEVEL_CHANGE: &str =
31 "https://schemas.openid.net/secevent/caep/event-type/assurance-level-change";
32 pub const DEVICE_COMPLIANCE_CHANGE: &str =
33 "https://schemas.openid.net/secevent/caep/event-type/device-compliance-change";
34}
35
36#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
40#[serde(tag = "format")]
41pub enum SubjectIdentifier {
42 #[serde(rename = "email")]
44 Email { email: String },
45 #[serde(rename = "iss_sub")]
47 IssSub { iss: String, sub: String },
48 #[serde(rename = "opaque")]
50 Opaque { id: String },
51 #[serde(rename = "phone_number")]
53 PhoneNumber { phone_number: String },
54 #[serde(rename = "session_id")]
56 SessionId {
57 session_id: String,
58 #[serde(default)]
59 iss: Option<String>,
60 },
61}
62
63#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
67#[serde(rename_all = "lowercase")]
68pub enum EventReasonAdmin {
69 Policy,
71 Admin,
73 User,
75}
76
77#[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#[derive(Debug, Clone, Serialize, Deserialize)]
89pub struct CaepEvent {
90 pub jti: String,
92 pub iss: String,
94 pub iat: u64,
96 pub event_type: String,
98 pub subject: SubjectIdentifier,
100 #[serde(default)]
102 pub initiating_entity: Option<EventReasonAdmin>,
103 #[serde(default)]
105 pub reason_admin: Option<String>,
106 #[serde(default)]
108 pub reason_user: Option<String>,
109 #[serde(default)]
111 pub properties: HashMap<String, serde_json::Value>,
112}
113
114impl CaepEvent {
115 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 pub fn with_initiating_entity(mut self, entity: EventReasonAdmin) -> Self {
137 self.initiating_entity = Some(entity);
138 self
139 }
140
141 pub fn with_reason_admin(mut self, reason: &str) -> Self {
143 self.reason_admin = Some(reason.to_string());
144 self
145 }
146
147 pub fn with_reason_user(mut self, reason: &str) -> Self {
149 self.reason_user = Some(reason.to_string());
150 self
151 }
152
153 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 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 let encoded = match entity {
172 EventReasonAdmin::Policy => "policy",
173 EventReasonAdmin::Admin => "admin",
174 EventReasonAdmin::User => "user",
175 };
176 event_body["initiating_entity"] = serde_json::Value::String(encoded.to_string());
177 }
178 if let Some(ref r) = self.reason_admin {
179 event_body["reason_admin"] = serde_json::json!({"en": r});
180 }
181 if let Some(ref r) = self.reason_user {
182 event_body["reason_user"] = serde_json::json!({"en": r});
183 }
184 for (k, v) in &self.properties {
185 event_body[k] = v.clone();
186 }
187 events.insert(self.event_type.clone(), event_body);
188
189 serde_json::json!({
190 "jti": self.jti,
191 "iss": self.iss,
192 "iat": self.iat,
193 "events": events,
194 })
195 }
196}
197
198#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
202#[serde(rename_all = "lowercase")]
203pub enum DeliveryMethod {
204 Push,
206 Poll,
208}
209
210#[derive(Debug, Clone, Serialize, Deserialize)]
212pub struct StreamConfig {
213 pub iss: String,
215 pub aud: Vec<String>,
217 pub events_supported: Vec<String>,
219 pub delivery_method: DeliveryMethod,
221 pub endpoint_url: String,
223}
224
225impl StreamConfig {
226 pub fn builder(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
228 StreamConfigBuilder {
229 iss: iss.into(),
230 aud: Vec::new(),
231 events_supported: Vec::new(),
232 delivery_method: DeliveryMethod::Push,
233 endpoint_url: endpoint_url.into(),
234 }
235 }
236
237 pub fn poll(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
239 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Poll)
240 }
241
242 pub fn push(iss: impl Into<String>, endpoint_url: impl Into<String>) -> StreamConfigBuilder {
244 Self::builder(iss, endpoint_url).delivery_method(DeliveryMethod::Push)
245 }
246}
247
248pub struct StreamConfigBuilder {
250 iss: String,
251 aud: Vec<String>,
252 events_supported: Vec<String>,
253 delivery_method: DeliveryMethod,
254 endpoint_url: String,
255}
256
257impl StreamConfigBuilder {
258 pub fn audience(mut self, audience: impl Into<String>) -> Self {
260 self.aud.push(audience.into());
261 self
262 }
263
264 pub fn audiences<I, S>(mut self, audiences: I) -> Self
266 where
267 I: IntoIterator<Item = S>,
268 S: Into<String>,
269 {
270 self.aud.extend(audiences.into_iter().map(Into::into));
271 self
272 }
273
274 pub fn supports_event(mut self, event_type: impl Into<String>) -> Self {
276 self.events_supported.push(event_type.into());
277 self
278 }
279
280 pub fn events_supported<I, S>(mut self, events: I) -> Self
282 where
283 I: IntoIterator<Item = S>,
284 S: Into<String>,
285 {
286 self.events_supported
287 .extend(events.into_iter().map(Into::into));
288 self
289 }
290
291 pub fn delivery_method(mut self, delivery_method: DeliveryMethod) -> Self {
293 self.delivery_method = delivery_method;
294 self
295 }
296
297 pub fn build(self) -> StreamConfig {
299 StreamConfig {
300 iss: self.iss,
301 aud: self.aud,
302 events_supported: self.events_supported,
303 delivery_method: self.delivery_method,
304 endpoint_url: self.endpoint_url,
305 }
306 }
307}
308
309#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
311#[serde(rename_all = "lowercase")]
312pub enum StreamStatus {
313 Enabled,
314 Paused,
315 Disabled,
316}
317
318struct EventStream {
322 config: StreamConfig,
323 status: StreamStatus,
324 events: Vec<CaepEvent>,
325}
326
327pub struct CaepTransmitter {
329 issuer: String,
330 streams: Arc<RwLock<HashMap<String, EventStream>>>,
331}
332
333impl CaepTransmitter {
334 pub fn new(issuer: &str) -> Self {
335 Self {
336 issuer: issuer.to_string(),
337 streams: Arc::new(RwLock::new(HashMap::new())),
338 }
339 }
340
341 pub async fn create_stream(&self, config: StreamConfig) -> String {
343 let stream_id = Uuid::new_v4().to_string();
344 self.streams.write().await.insert(
345 stream_id.clone(),
346 EventStream {
347 config,
348 status: StreamStatus::Enabled,
349 events: Vec::new(),
350 },
351 );
352 stream_id
353 }
354
355 pub async fn get_stream_config(&self, stream_id: &str) -> Option<StreamConfig> {
357 self.streams
358 .read()
359 .await
360 .get(stream_id)
361 .map(|s| s.config.clone())
362 }
363
364 pub async fn set_stream_status(&self, stream_id: &str, status: StreamStatus) -> Result<()> {
366 let mut streams = self.streams.write().await;
367 let stream = streams
368 .get_mut(stream_id)
369 .ok_or_else(|| AuthError::validation("Stream not found"))?;
370 stream.status = status;
371 Ok(())
372 }
373
374 pub async fn get_stream_status(&self, stream_id: &str) -> Option<StreamStatus> {
376 self.streams
377 .read()
378 .await
379 .get(stream_id)
380 .map(|s| s.status.clone())
381 }
382
383 pub async fn delete_stream(&self, stream_id: &str) -> bool {
385 self.streams.write().await.remove(stream_id).is_some()
386 }
387
388 pub async fn emit_session_revoked(
390 &self,
391 subject: SubjectIdentifier,
392 reason: Option<&str>,
393 ) -> Result<CaepEvent> {
394 let mut event = CaepEvent::new(&self.issuer, event_types::SESSION_REVOKED, subject);
395 if let Some(r) = reason {
396 event = event.with_reason_admin(r);
397 }
398 self.dispatch_event(&event).await;
399 Ok(event)
400 }
401
402 pub async fn emit_credential_change(
404 &self,
405 subject: SubjectIdentifier,
406 change_type: ChangeType,
407 ) -> Result<CaepEvent> {
408 let change_type_value = serde_json::to_value(&change_type).map_err(|e| {
409 AuthError::internal(format!("Failed to serialize CAEP change_type: {e}"))
410 })?;
411 let event = CaepEvent::new(&self.issuer, event_types::CREDENTIAL_CHANGE, subject)
412 .with_property("change_type", change_type_value);
413 self.dispatch_event(&event).await;
414 Ok(event)
415 }
416
417 pub async fn emit_device_compliance_change(
419 &self,
420 subject: SubjectIdentifier,
421 previous_status: &str,
422 current_status: &str,
423 ) -> Result<CaepEvent> {
424 let event = CaepEvent::new(&self.issuer, event_types::DEVICE_COMPLIANCE_CHANGE, subject)
425 .with_property("previous_status", serde_json::json!(previous_status))
426 .with_property("current_status", serde_json::json!(current_status));
427 self.dispatch_event(&event).await;
428 Ok(event)
429 }
430
431 pub async fn emit_token_claims_change(
435 &self,
436 subject: SubjectIdentifier,
437 claims: HashMap<String, serde_json::Value>,
438 ) -> Result<CaepEvent> {
439 let mut event = CaepEvent::new(&self.issuer, event_types::TOKEN_CLAIMS_CHANGE, subject);
440 let claims_value = serde_json::to_value(&claims)
441 .map_err(|e| AuthError::internal(format!("Failed to serialize CAEP claims: {e}")))?;
442 event = event.with_property("claims", claims_value);
443 self.dispatch_event(&event).await;
444 Ok(event)
445 }
446
447 pub async fn emit_assurance_level_change(
451 &self,
452 subject: SubjectIdentifier,
453 current_level: &str,
454 previous_level: &str,
455 change_direction: &str,
456 ) -> Result<CaepEvent> {
457 let event = CaepEvent::new(&self.issuer, event_types::ASSURANCE_LEVEL_CHANGE, subject)
458 .with_property("current_level", serde_json::json!(current_level))
459 .with_property("previous_level", serde_json::json!(previous_level))
460 .with_property("change_direction", serde_json::json!(change_direction));
461 self.dispatch_event(&event).await;
462 Ok(event)
463 }
464
465 pub async fn poll_events(&self, stream_id: &str) -> Result<Vec<CaepEvent>> {
467 let mut streams = self.streams.write().await;
468 let stream = streams
469 .get_mut(stream_id)
470 .ok_or_else(|| AuthError::validation("Stream not found"))?;
471
472 if stream.status != StreamStatus::Enabled {
473 return Err(AuthError::validation("Stream is not enabled"));
474 }
475
476 let events = std::mem::take(&mut stream.events);
477 Ok(events)
478 }
479
480 async fn dispatch_event(&self, event: &CaepEvent) {
482 let mut streams = self.streams.write().await;
483 for stream in streams.values_mut() {
484 if stream.status != StreamStatus::Enabled {
485 continue;
486 }
487 if stream.config.events_supported.is_empty()
489 || stream
490 .config
491 .events_supported
492 .iter()
493 .any(|e| e == &event.event_type)
494 {
495 stream.events.push(event.clone());
496 }
497 }
498 }
499
500 pub async fn active_stream_count(&self) -> usize {
502 self.streams
503 .read()
504 .await
505 .values()
506 .filter(|s| s.status == StreamStatus::Enabled)
507 .count()
508 }
509}
510
511pub type EventHandler = Arc<dyn Fn(&CaepEvent) + Send + Sync>;
515
516pub struct CaepReceiver {
518 handlers: Arc<RwLock<HashMap<String, Vec<EventHandler>>>>,
519 received_jtis: Arc<RwLock<std::collections::HashSet<String>>>,
520}
521
522impl CaepReceiver {
523 pub fn new() -> Self {
524 Self {
525 handlers: Arc::new(RwLock::new(HashMap::new())),
526 received_jtis: Arc::new(RwLock::new(std::collections::HashSet::new())),
527 }
528 }
529
530 pub async fn on_event(&self, event_type: &str, handler: EventHandler) {
532 self.handlers
533 .write()
534 .await
535 .entry(event_type.to_string())
536 .or_default()
537 .push(handler);
538 }
539
540 pub async fn process_event(&self, event: &CaepEvent) -> Result<bool> {
544 {
546 let mut jtis = self.received_jtis.write().await;
547 if !jtis.insert(event.jti.clone()) {
548 return Ok(false); }
550 }
551
552 let handlers = self.handlers.read().await;
554 if let Some(handler_list) = handlers.get(&event.event_type) {
555 for handler in handler_list {
556 handler(event);
557 }
558 }
559
560 Ok(true)
561 }
562
563 pub async fn was_processed(&self, jti: &str) -> bool {
565 self.received_jtis.read().await.contains(jti)
566 }
567}
568
569impl Default for CaepReceiver {
570 fn default() -> Self {
571 Self::new()
572 }
573}
574
575#[cfg(test)]
576mod tests {
577 use super::*;
578
579 #[test]
582 fn test_subject_email_serialization() {
583 let sub = SubjectIdentifier::Email {
584 email: "user@example.com".to_string(),
585 };
586 let json = serde_json::to_value(&sub).unwrap();
587 assert_eq!(json["format"], "email");
588 assert_eq!(json["email"], "user@example.com");
589 }
590
591 #[test]
592 fn test_subject_iss_sub_serialization() {
593 let sub = SubjectIdentifier::IssSub {
594 iss: "https://issuer.example".to_string(),
595 sub: "user-123".to_string(),
596 };
597 let json = serde_json::to_value(&sub).unwrap();
598 assert_eq!(json["format"], "iss_sub");
599 }
600
601 #[test]
602 fn test_subject_session_id_serialization() {
603 let sub = SubjectIdentifier::SessionId {
604 session_id: "sess-001".to_string(),
605 iss: Some("https://issuer.example".to_string()),
606 };
607 let json = serde_json::to_value(&sub).unwrap();
608 assert_eq!(json["format"], "session_id");
609 assert_eq!(json["session_id"], "sess-001");
610 }
611
612 #[test]
613 fn test_subject_roundtrip() {
614 let sub = SubjectIdentifier::Opaque {
615 id: "opaque-id-42".to_string(),
616 };
617 let serialized = serde_json::to_string(&sub).unwrap();
618 let deserialized: SubjectIdentifier = serde_json::from_str(&serialized).unwrap();
619 assert_eq!(sub, deserialized);
620 }
621
622 #[test]
625 fn test_event_creation() {
626 let event = CaepEvent::new(
627 "https://issuer.example",
628 event_types::SESSION_REVOKED,
629 SubjectIdentifier::Email {
630 email: "user@x.com".to_string(),
631 },
632 );
633 assert!(!event.jti.is_empty());
634 assert!(event.iat > 0);
635 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
636 }
637
638 #[test]
639 fn test_event_builder_chain() {
640 let event = CaepEvent::new(
641 "https://issuer.example",
642 event_types::CREDENTIAL_CHANGE,
643 SubjectIdentifier::Email {
644 email: "u@x.com".to_string(),
645 },
646 )
647 .with_initiating_entity(EventReasonAdmin::Admin)
648 .with_reason_admin("Password reset")
649 .with_reason_user("Your password was reset by admin")
650 .with_property("change_type", serde_json::json!("revoke"));
651
652 assert_eq!(event.initiating_entity, Some(EventReasonAdmin::Admin));
653 assert_eq!(event.reason_admin.as_deref(), Some("Password reset"));
654 assert!(event.properties.contains_key("change_type"));
655 }
656
657 #[test]
658 fn test_event_to_set_claims() {
659 let event = CaepEvent::new(
660 "https://iss.example",
661 event_types::SESSION_REVOKED,
662 SubjectIdentifier::Email {
663 email: "u@x.com".to_string(),
664 },
665 )
666 .with_reason_admin("Policy violation");
667
668 let claims = event.to_set_claims();
669 assert_eq!(claims["iss"], "https://iss.example");
670 assert!(claims["events"][event_types::SESSION_REVOKED].is_object());
671 let ev = &claims["events"][event_types::SESSION_REVOKED];
672 assert!(ev["subject"].is_object());
673 assert_eq!(ev["reason_admin"]["en"], "Policy violation");
674 }
675
676 #[tokio::test]
679 async fn test_transmitter_create_stream() {
680 let tx = CaepTransmitter::new("https://issuer.example");
681 let config =
682 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
683 .audience("https://receiver.example")
684 .supports_event(event_types::SESSION_REVOKED)
685 .build();
686 let stream_id = tx.create_stream(config.clone()).await;
687 assert!(!stream_id.is_empty());
688 assert_eq!(tx.active_stream_count().await, 1);
689
690 let retrieved = tx.get_stream_config(&stream_id).await.unwrap();
691 assert_eq!(retrieved.iss, config.iss);
692 }
693
694 #[tokio::test]
695 async fn test_transmitter_stream_status() {
696 let tx = CaepTransmitter::new("https://iss.example");
697 let id = tx
698 .create_stream(StreamConfig::poll("https://iss.example", "").build())
699 .await;
700
701 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Enabled));
702
703 tx.set_stream_status(&id, StreamStatus::Paused)
704 .await
705 .unwrap();
706 assert_eq!(tx.get_stream_status(&id).await, Some(StreamStatus::Paused));
707 assert_eq!(tx.active_stream_count().await, 0);
708 }
709
710 #[tokio::test]
711 async fn test_transmitter_delete_stream() {
712 let tx = CaepTransmitter::new("https://iss.example");
713 let id = tx.create_stream(StreamConfig::push("", "").build()).await;
714
715 assert!(tx.delete_stream(&id).await);
716 assert!(!tx.delete_stream(&id).await); assert_eq!(tx.active_stream_count().await, 0);
718 }
719
720 #[tokio::test]
721 async fn test_transmitter_emit_session_revoked() {
722 let tx = CaepTransmitter::new("https://iss.example");
723 let id = tx
724 .create_stream(
725 StreamConfig::poll("", "")
726 .supports_event(event_types::SESSION_REVOKED)
727 .build(),
728 )
729 .await;
730
731 let event = tx
732 .emit_session_revoked(
733 SubjectIdentifier::Email {
734 email: "u@x.com".to_string(),
735 },
736 Some("Security policy"),
737 )
738 .await
739 .unwrap();
740
741 assert_eq!(event.event_type, event_types::SESSION_REVOKED);
742
743 let events = tx.poll_events(&id).await.unwrap();
744 assert_eq!(events.len(), 1);
745 assert_eq!(events[0].jti, event.jti);
746
747 let events2 = tx.poll_events(&id).await.unwrap();
749 assert!(events2.is_empty());
750 }
751
752 #[tokio::test]
753 async fn test_transmitter_event_filtering() {
754 let tx = CaepTransmitter::new("https://iss.example");
755
756 let id = tx
758 .create_stream(
759 StreamConfig::poll("", "")
760 .supports_event(event_types::SESSION_REVOKED)
761 .build(),
762 )
763 .await;
764
765 tx.emit_credential_change(
767 SubjectIdentifier::Email {
768 email: "u@x.com".to_string(),
769 },
770 ChangeType::Revoke,
771 )
772 .await
773 .unwrap();
774
775 let events = tx.poll_events(&id).await.unwrap();
776 assert!(events.is_empty());
777 }
778
779 #[tokio::test]
780 async fn test_transmitter_paused_stream_no_events() {
781 let tx = CaepTransmitter::new("https://iss.example");
782 let id = tx.create_stream(StreamConfig::poll("", "").build()).await;
783
784 tx.set_stream_status(&id, StreamStatus::Paused)
785 .await
786 .unwrap();
787
788 tx.emit_session_revoked(
789 SubjectIdentifier::Email {
790 email: "u@x.com".to_string(),
791 },
792 None,
793 )
794 .await
795 .unwrap();
796
797 assert!(tx.poll_events(&id).await.is_err());
799 }
800
801 #[tokio::test]
804 async fn test_receiver_process_event() {
805 let rx = CaepReceiver::new();
806 let called = Arc::new(std::sync::atomic::AtomicBool::new(false));
807 let called_clone = called.clone();
808
809 rx.on_event(
810 event_types::SESSION_REVOKED,
811 Arc::new(move |_event| {
812 called_clone.store(true, std::sync::atomic::Ordering::SeqCst);
813 }),
814 )
815 .await;
816
817 let event = CaepEvent::new(
818 "https://iss.example",
819 event_types::SESSION_REVOKED,
820 SubjectIdentifier::Email {
821 email: "u@x.com".to_string(),
822 },
823 );
824
825 let processed = rx.process_event(&event).await.unwrap();
826 assert!(processed);
827 assert!(called.load(std::sync::atomic::Ordering::SeqCst));
828 }
829
830 #[test]
831 fn test_stream_config_builder() {
832 let config =
833 StreamConfig::poll("https://issuer.example", "https://receiver.example/events")
834 .audience("https://receiver.example")
835 .audiences(["https://backup.example"])
836 .supports_event(event_types::SESSION_REVOKED)
837 .events_supported([event_types::CREDENTIAL_CHANGE])
838 .build();
839
840 assert_eq!(config.delivery_method, DeliveryMethod::Poll);
841 assert_eq!(config.aud.len(), 2);
842 assert_eq!(config.events_supported.len(), 2);
843 }
844
845 #[tokio::test]
846 async fn test_receiver_deduplication() {
847 let rx = CaepReceiver::new();
848 let event = CaepEvent::new(
849 "https://iss.example",
850 event_types::CREDENTIAL_CHANGE,
851 SubjectIdentifier::Opaque {
852 id: "x".to_string(),
853 },
854 );
855
856 let first = rx.process_event(&event).await.unwrap();
857 assert!(first);
858
859 let second = rx.process_event(&event).await.unwrap();
860 assert!(!second); assert!(rx.was_processed(&event.jti).await);
863 }
864
865 #[tokio::test]
866 async fn test_receiver_unhandled_event_type() {
867 let rx = CaepReceiver::new();
868 let event = CaepEvent::new(
869 "https://iss.example",
870 "custom:unknown-event",
871 SubjectIdentifier::Opaque {
872 id: "x".to_string(),
873 },
874 );
875 let processed = rx.process_event(&event).await.unwrap();
877 assert!(processed);
878 }
879
880 #[test]
883 fn test_delivery_method_serialization() {
884 assert_eq!(
885 serde_json::to_string(&DeliveryMethod::Push).unwrap(),
886 r#""push""#
887 );
888 assert_eq!(
889 serde_json::to_string(&DeliveryMethod::Poll).unwrap(),
890 r#""poll""#
891 );
892 }
893}