1use crate::audit::{
2 ActorInfo, AuditEvent, AuditEventType, EventOutcome, RequestMetadata, ResourceInfo, RiskLevel,
3};
4use crate::errors::Result;
17use crate::storage::core::{AuthStorage, SessionData};
18use crate::tokens::AuthToken;
19use async_trait::async_trait;
20use dashmap::DashMap;
21use std::time::Duration;
22
23#[derive(Debug, Clone)]
25struct TimestampedToken {
26 token: AuthToken,
27 created_at: chrono::DateTime<chrono::Utc>,
28 expires_at: Option<chrono::DateTime<chrono::Utc>>,
29}
30
31#[derive(Debug, Clone)]
33struct TimestampedSession {
34 session: SessionData,
35 created_at: chrono::DateTime<chrono::Utc>,
36}
37
38#[derive(Clone)]
40struct TimestampedValue {
41 data: Vec<u8>,
42 created_at: chrono::DateTime<chrono::Utc>,
43 expires_at: Option<chrono::DateTime<chrono::Utc>>,
44}
45
46impl std::fmt::Debug for TimestampedValue {
47 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 let mut d = f.debug_struct("TimestampedValue");
49 d.field("data", &crate::utils::redact::redacted(&self.data));
50 d.field("created_at", &self.created_at);
51 d.field("expires_at", &self.expires_at);
52 d.finish()
53 }
54}
55
56impl TimestampedToken {
57 fn new(token: AuthToken, ttl: Option<Duration>) -> Self {
58 let now = chrono::Utc::now();
59 let expires_at =
60 ttl.map(|d| now + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::hours(1)));
61
62 Self {
63 token,
64 created_at: now,
65 expires_at,
66 }
67 }
68
69 fn is_expired(&self) -> bool {
70 self.expires_at
71 .map(|exp| chrono::Utc::now() > exp)
72 .unwrap_or(false)
73 }
74}
75
76impl TimestampedSession {
77 fn new(session: SessionData) -> Self {
78 Self {
79 session,
80 created_at: chrono::Utc::now(),
81 }
82 }
83
84 fn is_expired(&self) -> bool {
85 self.session.is_expired()
86 }
87}
88
89impl TimestampedValue {
90 fn new(data: Vec<u8>, ttl: Option<Duration>) -> Self {
91 let now = chrono::Utc::now();
92 let expires_at =
93 ttl.map(|d| now + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::hours(1)));
94
95 Self {
96 data,
97 created_at: now,
98 expires_at,
99 }
100 }
101
102 fn is_expired(&self) -> bool {
103 self.expires_at
104 .map(|exp| chrono::Utc::now() > exp)
105 .unwrap_or(false)
106 }
107}
108
109#[derive(Clone)]
111pub struct DashMapMemoryStorage {
112 tokens: DashMap<String, TimestampedToken>,
114 sessions: DashMap<String, TimestampedSession>,
115 kv_store: DashMap<String, TimestampedValue>,
116
117 access_token_to_id: DashMap<String, String>,
119 user_to_tokens: DashMap<String, Vec<String>>,
120 user_to_sessions: DashMap<String, Vec<String>>,
121
122 default_ttl: Option<Duration>,
124}
125
126impl std::fmt::Debug for DashMapMemoryStorage {
127 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
128 let mut d = f.debug_struct("DashMapMemoryStorage");
129 d.field("tokens", &crate::utils::redact::redacted(&self.tokens));
130 d.field("sessions", &crate::utils::redact::redacted(&self.sessions));
131 d.field("kv_store", &crate::utils::redact::redacted(&self.kv_store));
132 d.field(
133 "access_token_to_id",
134 &crate::utils::redact::redacted(&self.access_token_to_id),
135 );
136 d.field(
137 "user_to_tokens",
138 &crate::utils::redact::redacted(&self.user_to_tokens),
139 );
140 d.field(
141 "user_to_sessions",
142 &crate::utils::redact::redacted(&self.user_to_sessions),
143 );
144 d.field("default_ttl", &self.default_ttl);
145 d.finish()
146 }
147}
148
149impl Default for DashMapMemoryStorage {
150 fn default() -> Self {
151 Self::new()
152 }
153}
154
155impl DashMapMemoryStorage {
156 pub fn new() -> Self {
158 Self {
159 tokens: DashMap::new(),
160 sessions: DashMap::new(),
161 kv_store: DashMap::new(),
162 access_token_to_id: DashMap::new(),
163 user_to_tokens: DashMap::new(),
164 user_to_sessions: DashMap::new(),
165 default_ttl: None,
166 }
167 }
168
169 pub fn with_ttl(ttl: Duration) -> Self {
171 Self {
172 tokens: DashMap::new(),
173 sessions: DashMap::new(),
174 kv_store: DashMap::new(),
175 access_token_to_id: DashMap::new(),
176 user_to_tokens: DashMap::new(),
177 user_to_sessions: DashMap::new(),
178 default_ttl: Some(ttl),
179 }
180 }
181
182 fn create_audit_event(
184 &self,
185 event_type: AuditEventType,
186 user_id: &str,
187 resource_id: &str,
188 resource_type: &str,
189 outcome: EventOutcome,
190 details_str: Option<&str>,
191 ) -> AuditEvent {
192 let mut details = std::collections::HashMap::new();
193 if let Some(detail) = details_str {
194 details.insert("operation_details".to_string(), detail.to_string());
195 }
196 details.insert("resource_type".to_string(), resource_type.to_string());
197 details.insert("resource_id".to_string(), resource_id.to_string());
198
199 let risk_level = match &event_type {
200 AuditEventType::TokenRevoked | AuditEventType::TokenExpired => RiskLevel::Medium,
201 AuditEventType::SuspiciousActivity => RiskLevel::High,
202 _ => RiskLevel::Low,
203 };
204
205 AuditEvent::builder(
206 event_type.clone(),
207 format!(
208 "{:?} operation on {} {}",
209 event_type, resource_type, resource_id
210 ),
211 )
212 .user_id(user_id)
213 .outcome(outcome)
214 .risk_level(risk_level)
215 .details(details)
216 .request_metadata(RequestMetadata::new().with_endpoint("storage"))
217 .resource(ResourceInfo {
218 resource_type: resource_type.to_string(),
219 resource_id: resource_id.to_string(),
220 resource_name: None,
221 attributes: std::collections::HashMap::new(),
222 })
223 .actor(ActorInfo {
224 actor_type: "storage_system".to_string(),
225 actor_id: user_id.to_string(),
226 actor_name: Some(user_id.to_string()),
227 roles: vec!["storage_user".to_string()],
228 })
229 .build()
230 }
231
232 async fn log_storage_operation(
234 &self,
235 event_type: AuditEventType,
236 user_id: &str,
237 resource_id: &str,
238 resource_type: &str,
239 created_at: Option<chrono::DateTime<chrono::Utc>>,
240 outcome: EventOutcome,
241 ) {
242 let resource_ref = crate::utils::redact::fingerprint(resource_id).to_string();
243 let details = if let Some(created) = created_at {
244 let age = chrono::Utc::now().signed_duration_since(created);
245 format!(
246 "{:?} operation on {} {} (age: {} seconds)",
247 event_type,
248 resource_type,
249 resource_ref,
250 age.num_seconds()
251 )
252 } else {
253 format!(
254 "{:?} operation on {} {}",
255 event_type, resource_type, resource_ref
256 )
257 };
258
259 let audit_event = self.create_audit_event(
260 event_type,
261 user_id,
262 &resource_ref,
263 resource_type,
264 outcome,
265 Some(&details),
266 );
267
268 tracing::info!(
270 "STORAGE AUDIT: {}",
271 serde_json::to_string(&audit_event).unwrap_or_default()
272 );
273 }
274
275 pub fn get_storage_statistics(&self) -> std::collections::HashMap<String, serde_json::Value> {
277 let mut stats = std::collections::HashMap::new();
278 stats.insert(
279 "total_tokens".to_string(),
280 serde_json::Value::from(self.tokens.len()),
281 );
282 stats.insert(
283 "total_sessions".to_string(),
284 serde_json::Value::from(self.sessions.len()),
285 );
286 stats.insert(
287 "total_kv_pairs".to_string(),
288 serde_json::Value::from(self.kv_store.len()),
289 );
290 stats.insert(
291 "total_users_with_tokens".to_string(),
292 serde_json::Value::from(self.user_to_tokens.len()),
293 );
294 stats.insert(
295 "total_users_with_sessions".to_string(),
296 serde_json::Value::from(self.user_to_sessions.len()),
297 );
298 stats.insert(
299 "timestamp".to_string(),
300 serde_json::Value::from(chrono::Utc::now().to_rfc3339()),
301 );
302 stats
303 }
304
305 pub fn audit_token_ages(&self) -> Vec<(String, String, i64)> {
307 let mut aged_tokens = Vec::new();
308 let now = chrono::Utc::now();
309
310 for entry in self.tokens.iter() {
311 let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
312 aged_tokens.push((
313 entry.key().clone(),
314 entry.token.user_id.clone(),
315 age_seconds,
316 ));
317 }
318
319 aged_tokens.sort_by_key(|entry| std::cmp::Reverse(entry.2)); aged_tokens
321 }
322
323 pub fn audit_session_ages(&self) -> Vec<(String, String, i64)> {
325 let mut aged_sessions = Vec::new();
326 let now = chrono::Utc::now();
327
328 for entry in self.sessions.iter() {
329 let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
330 aged_sessions.push((
331 entry.key().clone(),
332 entry.session.user_id.clone(),
333 age_seconds,
334 ));
335 }
336
337 aged_sessions.sort_by_key(|entry| std::cmp::Reverse(entry.2)); aged_sessions
339 }
340
341 pub fn generate_audit_report(&self) -> std::collections::HashMap<String, serde_json::Value> {
343 let mut report = self.get_storage_statistics();
344
345 let token_ages = self.audit_token_ages();
346 let session_ages = self.audit_session_ages();
347
348 if !token_ages.is_empty() {
350 report.insert(
351 "oldest_token_age_seconds".to_string(),
352 serde_json::Value::from(token_ages[0].2),
353 );
354 report.insert(
355 "tokens_older_than_24h".to_string(),
356 serde_json::Value::from(
357 token_ages.iter().filter(|(_, _, age)| *age > 86400).count(),
358 ),
359 );
360 }
361
362 if !session_ages.is_empty() {
363 report.insert(
364 "oldest_session_age_seconds".to_string(),
365 serde_json::Value::from(session_ages[0].2),
366 );
367 report.insert(
368 "sessions_older_than_24h".to_string(),
369 serde_json::Value::from(
370 session_ages
371 .iter()
372 .filter(|(_, _, age)| *age > 86400)
373 .count(),
374 ),
375 );
376 }
377
378 report
379 }
380
381 fn add_token_to_user_index(&self, user_id: &str, token_id: &str) {
384 self.user_to_tokens
386 .entry(user_id.to_string())
387 .and_modify(|tokens| tokens.push(token_id.to_string()))
388 .or_insert_with(|| vec![token_id.to_string()]);
389 }
390
391 fn remove_token_from_user_index(&self, user_id: &str, token_id: &str) {
393 if let Some(mut entry) = self.user_to_tokens.get_mut(user_id) {
395 entry.retain(|id| id != token_id);
396 if entry.is_empty() {
397 drop(entry); self.user_to_tokens.remove(user_id);
399 }
400 }
401 }
402
403 fn add_session_to_user_index(&self, user_id: &str, session_id: &str) {
405 self.user_to_sessions
406 .entry(user_id.to_string())
407 .and_modify(|sessions| sessions.push(session_id.to_string()))
408 .or_insert_with(|| vec![session_id.to_string()]);
409 }
410
411 fn remove_session_from_user_index(&self, user_id: &str, session_id: &str) {
413 if let Some(mut entry) = self.user_to_sessions.get_mut(user_id) {
414 entry.retain(|id| id != session_id);
415 if entry.is_empty() {
416 drop(entry);
417 self.user_to_sessions.remove(user_id);
418 }
419 }
420 }
421
422 pub fn list_kv_keys_by_prefix(&self, prefix: &str) -> Vec<String> {
424 self.kv_store
425 .iter()
426 .filter_map(|entry| {
427 if entry.key().starts_with(prefix) {
428 Some(entry.key().clone())
429 } else {
430 None
431 }
432 })
433 .collect()
434 }
435}
436
437#[async_trait]
438impl AuthStorage for DashMapMemoryStorage {
439 async fn store_token(&self, token: &AuthToken) -> Result<()> {
440 let timestamped = TimestampedToken::new(token.clone(), self.default_ttl);
441 let created_at = timestamped.created_at;
442
443 self.tokens.insert(token.token_id.clone(), timestamped);
445
446 self.access_token_to_id
448 .insert(token.access_token.clone(), token.token_id.clone());
449
450 self.add_token_to_user_index(&token.user_id, &token.token_id);
452
453 self.log_storage_operation(
455 AuditEventType::LoginSuccess, &token.user_id,
457 &token.token_id,
458 "token",
459 Some(created_at),
460 EventOutcome::Success,
461 )
462 .await;
463
464 Ok(())
465 }
466
467 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
468 if let Some(timestamped) = self.tokens.get(token_id) {
470 let created_at = timestamped.created_at;
471 let user_id = timestamped.token.user_id.clone();
472
473 if timestamped.is_expired() || timestamped.token.is_expired() {
475 drop(timestamped); self.tokens.remove(token_id); self.log_storage_operation(
480 AuditEventType::TokenExpired,
481 &user_id,
482 token_id,
483 "token",
484 Some(created_at),
485 EventOutcome::Failure,
486 )
487 .await;
488
489 return Ok(None);
490 }
491
492 let token = timestamped.token.clone();
493 drop(timestamped); self.log_storage_operation(
497 AuditEventType::LoginSuccess, &user_id,
499 token_id,
500 "token",
501 Some(created_at),
502 EventOutcome::Success,
503 )
504 .await;
505
506 Ok(Some(token))
507 } else {
508 Ok(None)
509 }
510 }
511
512 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
513 if let Some(token_id_entry) = self.access_token_to_id.get(access_token) {
515 let token_id = token_id_entry.clone(); drop(token_id_entry); self.get_token(&token_id).await } else {
519 Ok(None)
520 }
521 }
522
523 async fn update_token(&self, token: &AuthToken) -> Result<()> {
524 self.store_token(token).await
526 }
527
528 async fn delete_token(&self, token_id: &str) -> Result<()> {
529 let token_info = if let Some(timestamped) = self.tokens.get(token_id) {
531 Some((
532 timestamped.token.user_id.clone(),
533 timestamped.token.access_token.clone(),
534 timestamped.created_at,
535 ))
536 } else {
537 None
538 };
539
540 if let Some((user_id, access_token, created_at)) = token_info {
541 self.tokens.remove(token_id);
543 self.access_token_to_id.remove(&access_token);
544 self.remove_token_from_user_index(&user_id, token_id);
545
546 self.log_storage_operation(
548 AuditEventType::TokenRevoked,
549 &user_id,
550 token_id,
551 "token",
552 Some(created_at),
553 EventOutcome::Success,
554 )
555 .await;
556 }
557
558 Ok(())
559 }
560
561 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
562 let token_ids = if let Some(ids) = self.user_to_tokens.get(user_id) {
564 ids.clone() } else {
566 return Ok(Vec::new());
567 };
568
569 let mut tokens = Vec::new();
570 let mut expired_tokens = Vec::new();
571
572 for token_id in token_ids {
574 if let Some(timestamped) = self.tokens.get(&token_id) {
575 if timestamped.is_expired() {
576 expired_tokens.push(token_id);
577 } else {
578 tokens.push(timestamped.token.clone());
579 }
580 } else {
581 expired_tokens.push(token_id); }
583 }
584
585 for token_id in expired_tokens {
587 self.delete_token(&token_id).await?;
588 }
589
590 Ok(tokens)
591 }
592
593 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
594 let timestamped = TimestampedSession::new(data.clone());
595 let created_at = timestamped.created_at;
596
597 self.sessions.insert(session_id.to_string(), timestamped);
599
600 self.add_session_to_user_index(&data.user_id, session_id);
602
603 self.log_storage_operation(
605 AuditEventType::LoginSuccess, &data.user_id,
607 session_id,
608 "session",
609 Some(created_at),
610 EventOutcome::Success,
611 )
612 .await;
613
614 Ok(())
615 }
616
617 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
618 if let Some(timestamped) = self.sessions.get(session_id) {
620 let created_at = timestamped.created_at;
621 let user_id = timestamped.session.user_id.clone();
622
623 if timestamped.is_expired() || timestamped.session.expires_at <= chrono::Utc::now() {
625 drop(timestamped);
626 self.sessions.remove(session_id);
627
628 self.log_storage_operation(
630 AuditEventType::TokenExpired, &user_id,
632 session_id,
633 "session",
634 Some(created_at),
635 EventOutcome::Failure,
636 )
637 .await;
638
639 return Ok(None);
640 }
641
642 let session = timestamped.session.clone();
643 drop(timestamped);
644
645 self.log_storage_operation(
647 AuditEventType::LoginSuccess, &user_id,
649 session_id,
650 "session",
651 Some(created_at),
652 EventOutcome::Success,
653 )
654 .await;
655
656 Ok(Some(session))
657 } else {
658 Ok(None)
659 }
660 }
661
662 async fn delete_session(&self, session_id: &str) -> Result<()> {
663 let session_info = if let Some(timestamped) = self.sessions.get(session_id) {
665 Some((timestamped.session.user_id.clone(), timestamped.created_at))
666 } else {
667 None
668 };
669
670 if let Some((user_id, created_at)) = session_info {
671 self.sessions.remove(session_id);
672 self.remove_session_from_user_index(&user_id, session_id);
673
674 self.log_storage_operation(
676 AuditEventType::Logout,
677 &user_id,
678 session_id,
679 "session",
680 Some(created_at),
681 EventOutcome::Success,
682 )
683 .await;
684 }
685
686 Ok(())
687 }
688
689 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
690 let session_ids = if let Some(ids) = self.user_to_sessions.get(user_id) {
692 ids.clone()
693 } else {
694 return Ok(Vec::new());
695 };
696
697 let mut sessions = Vec::new();
698 let mut expired_sessions = Vec::new();
699
700 for session_id in session_ids {
702 if let Some(timestamped) = self.sessions.get(&session_id) {
703 if timestamped.is_expired() {
704 expired_sessions.push(session_id);
705 } else {
706 sessions.push(timestamped.session.clone());
707 }
708 } else {
709 expired_sessions.push(session_id);
710 }
711 }
712
713 for session_id in expired_sessions {
715 self.delete_session(&session_id).await?;
716 }
717
718 Ok(sessions)
719 }
720
721 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
722 let timestamped = TimestampedValue::new(value.to_vec(), ttl.or(self.default_ttl));
723 let created_at = timestamped.created_at;
724
725 self.kv_store.insert(key.to_string(), timestamped);
726
727 self.log_storage_operation(
729 AuditEventType::ConfigurationChanged, "system", key,
732 "kv_pair",
733 Some(created_at),
734 EventOutcome::Success,
735 )
736 .await;
737
738 Ok(())
739 }
740
741 async fn store_kv_if_absent(
742 &self,
743 key: &str,
744 value: &[u8],
745 ttl: Option<Duration>,
746 ) -> Result<bool> {
747 use dashmap::mapref::entry::Entry;
748 let fresh = TimestampedValue::new(value.to_vec(), ttl.or(self.default_ttl));
749 Ok(match self.kv_store.entry(key.to_string()) {
751 Entry::Occupied(mut occupied) => {
752 if occupied.get().is_expired() {
753 occupied.insert(fresh);
754 true
755 } else {
756 false
757 }
758 }
759 Entry::Vacant(vacant) => {
760 vacant.insert(fresh);
761 true
762 }
763 })
764 }
765
766 async fn swap_kv(
767 &self,
768 remove: &[String],
769 key: &str,
770 value: &[u8],
771 ttl: Option<Duration>,
772 ) -> Result<bool> {
773 crate::storage::core::swap_kv_in_process(self, remove, key, value, ttl).await
774 }
775
776 fn supports_atomic_swap(&self) -> bool {
777 true
778 }
779
780 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
781 if let Some(timestamped) = self.kv_store.get(key) {
783 let created_at = timestamped.created_at;
784
785 if timestamped.is_expired() {
786 drop(timestamped);
787 self.kv_store.remove(key);
788
789 self.log_storage_operation(
791 AuditEventType::TokenExpired, "system",
793 key,
794 "kv_pair",
795 Some(created_at),
796 EventOutcome::Failure,
797 )
798 .await;
799
800 return Ok(None);
801 }
802
803 let data = timestamped.data.clone();
804 drop(timestamped);
805
806 self.log_storage_operation(
808 AuditEventType::ConfigurationChanged, "system",
810 key,
811 "kv_pair",
812 Some(created_at),
813 EventOutcome::Success,
814 )
815 .await;
816
817 Ok(Some(data))
818 } else {
819 Ok(None)
820 }
821 }
822
823 async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
824 Ok(self.kv_store.get(key).and_then(|entry| {
825 entry
826 .expires_at
827 .and_then(|expires_at| (expires_at - chrono::Utc::now()).to_std().ok())
828 .filter(|remaining| !remaining.is_zero())
829 }))
830 }
831
832 fn tracks_kv_ttl(&self) -> bool {
833 true
834 }
835
836 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
837 Ok(self
838 .kv_store
839 .iter()
840 .filter(|entry| entry.key().starts_with(prefix) && !entry.value().is_expired())
841 .map(|entry| entry.key().clone())
842 .collect())
843 }
844
845 async fn delete_kv(&self, key: &str) -> Result<()> {
846 let created_at = if let Some(timestamped) = self.kv_store.get(key) {
848 Some(timestamped.created_at)
849 } else {
850 None
851 };
852
853 self.kv_store.remove(key);
854
855 if let Some(created_at) = created_at {
856 self.log_storage_operation(
858 AuditEventType::ConfigurationChanged, "system",
860 key,
861 "kv_pair",
862 Some(created_at),
863 EventOutcome::Success,
864 )
865 .await;
866 }
867
868 Ok(())
869 }
870
871 async fn cleanup_expired(&self) -> Result<()> {
872 let mut expired_tokens = Vec::new();
874 let mut expired_sessions = Vec::new();
875 let mut expired_kvs = Vec::new();
876
877 for entry in self.tokens.iter() {
879 if entry.is_expired() {
880 expired_tokens.push(entry.key().clone());
881 }
882 }
883
884 for entry in self.sessions.iter() {
885 if entry.is_expired() {
886 expired_sessions.push(entry.key().clone());
887 }
888 }
889
890 for entry in self.kv_store.iter() {
891 if entry.is_expired() {
892 expired_kvs.push(entry.key().clone());
893 }
894 }
895
896 for token_id in expired_tokens {
898 self.delete_token(&token_id).await?;
899 }
900
901 for session_id in expired_sessions {
902 self.delete_session(&session_id).await?;
903 }
904
905 for key in expired_kvs {
906 self.delete_kv(&key).await?;
907 }
908
909 Ok(())
910 }
911
912 async fn count_active_sessions(&self) -> Result<u64> {
913 let mut count = 0;
914
915 for entry in self.sessions.iter() {
917 if !entry.is_expired() {
918 count += 1;
919 }
920 }
921
922 Ok(count)
923 }
924}
925
926#[cfg(test)]
927mod tests {
928 use super::*;
929 use crate::{
930 testing::test_infrastructure::TestEnvironmentGuard,
931 tokens::TokenMetadata,
932 types::{Permissions, Roles, Scopes},
933 };
934 use std::collections::HashMap;
935 use tokio::task::JoinSet;
936
937 #[tokio::test]
938 async fn test_basic_token_operations() {
939 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-test");
940 let storage = DashMapMemoryStorage::new();
941
942 let token = AuthToken {
943 token_id: "test-token".to_string(),
944 user_id: "test-user".to_string(),
945 access_token: "access-123".to_string(),
946 token_type: Some("bearer".to_string()),
947 subject: Some("test-user".to_string()),
948 issuer: Some("test-issuer".to_string()),
949 refresh_token: None,
950 issued_at: chrono::Utc::now(),
951 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
952 scopes: Scopes::new(vec!["read".to_string()]),
953 auth_method: "password".to_string(),
954 client_id: Some("test-client".to_string()),
955 user_profile: None,
956 permissions: Permissions::new(vec!["read:data".to_string()]),
957 roles: Roles::new(vec!["user".to_string()]),
958 metadata: TokenMetadata::default(),
959 };
960
961 storage.store_token(&token).await.unwrap();
963
964 let retrieved = storage.get_token("test-token").await.unwrap().unwrap();
966 assert_eq!(retrieved.user_id, "test-user");
967
968 let retrieved = storage
970 .get_token_by_access_token("access-123")
971 .await
972 .unwrap()
973 .unwrap();
974 assert_eq!(retrieved.token_id, "test-token");
975
976 let user_tokens = storage.list_user_tokens("test-user").await.unwrap();
978 assert_eq!(user_tokens.len(), 1);
979
980 storage.delete_token("test-token").await.unwrap();
982 let retrieved = storage.get_token("test-token").await.unwrap();
983 assert!(retrieved.is_none());
984 }
985
986 #[tokio::test]
987 async fn test_session_operations() {
988 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-session-test");
989 let storage = DashMapMemoryStorage::new();
990
991 let session = SessionData {
992 session_id: "test-session".to_string(),
993 user_id: "test-user".to_string(),
994 created_at: chrono::Utc::now(),
995 last_activity: chrono::Utc::now(),
996 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
997 ip_address: Some("192.168.1.1".to_string()),
998 user_agent: Some("test-agent".to_string()),
999 data: HashMap::new(),
1000 };
1001
1002 storage
1004 .store_session("test-session", &session)
1005 .await
1006 .unwrap();
1007
1008 let retrieved = storage.get_session("test-session").await.unwrap().unwrap();
1010 assert_eq!(retrieved.user_id, "test-user");
1011
1012 let user_sessions = storage.list_user_sessions("test-user").await.unwrap();
1014 assert_eq!(user_sessions.len(), 1);
1015
1016 storage.delete_session("test-session").await.unwrap();
1018 let retrieved = storage.get_session("test-session").await.unwrap();
1019 assert!(retrieved.is_none());
1020 }
1021
1022 #[tokio::test]
1023 async fn test_kv_operations() {
1024 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-kv-test");
1025 let storage = DashMapMemoryStorage::new();
1026
1027 let key = "test-key";
1028 let value = b"test-value";
1029
1030 storage
1032 .store_kv(key, value, Some(Duration::from_secs(3600)))
1033 .await
1034 .unwrap();
1035
1036 let retrieved = storage.get_kv(key).await.unwrap().unwrap();
1038 assert_eq!(retrieved, value);
1039
1040 storage.delete_kv(key).await.unwrap();
1042 let retrieved = storage.get_kv(key).await.unwrap();
1043 assert!(retrieved.is_none());
1044 }
1045
1046 #[tokio::test]
1047 async fn test_concurrent_operations_no_deadlock() {
1048 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-concurrent-test");
1049 let storage = std::sync::Arc::new(DashMapMemoryStorage::new());
1050
1051 let mut join_set = JoinSet::new();
1052
1053 for i in 0..10 {
1055 let storage = storage.clone();
1056 join_set.spawn(async move {
1057 for j in 0..50 {
1058 let token = AuthToken {
1059 token_id: format!("token-{}-{}", i, j),
1060 user_id: format!("user-{}", i % 3), access_token: format!("access-{}-{}", i, j),
1062 token_type: Some("bearer".to_string()),
1063 subject: Some(format!("user-{}", i % 3)),
1064 issuer: Some("test-issuer".to_string()),
1065 refresh_token: None,
1066 issued_at: chrono::Utc::now(),
1067 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
1068 scopes: Scopes::new(vec!["read".to_string()]),
1069 auth_method: "password".to_string(),
1070 client_id: Some("test-client".to_string()),
1071 user_profile: None,
1072 permissions: Permissions::new(vec!["read:data".to_string()]),
1073 roles: Roles::new(vec!["user".to_string()]),
1074 metadata: TokenMetadata::default(),
1075 };
1076
1077 storage.store_token(&token).await.unwrap();
1079
1080 let _user_tokens = storage.list_user_tokens(&token.user_id).await.unwrap();
1082
1083 let _retrieved = storage
1085 .get_token_by_access_token(&token.access_token)
1086 .await
1087 .unwrap();
1088 }
1089 });
1090 }
1091
1092 while join_set.join_next().await.is_some() {}
1094
1095 println!("✅ Concurrent operations test passed - no deadlocks detected!");
1096 }
1097
1098 #[tokio::test]
1099 async fn test_ttl_expiration() {
1100 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-ttl-test");
1101 let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(100));
1102
1103 storage
1105 .store_kv("expiring-key", b"expiring-value", None)
1106 .await
1107 .unwrap();
1108
1109 let retrieved = storage.get_kv("expiring-key").await.unwrap();
1111 assert!(retrieved.is_some());
1112
1113 tokio::time::sleep(Duration::from_millis(150)).await;
1115
1116 let retrieved = storage.get_kv("expiring-key").await.unwrap();
1118 assert!(retrieved.is_none());
1119 }
1120
1121 #[tokio::test]
1122 async fn test_cleanup_expired() {
1123 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-cleanup-test");
1124 let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(50));
1125
1126 for i in 0..10 {
1128 storage
1129 .store_kv(&format!("key-{}", i), b"value", None)
1130 .await
1131 .unwrap();
1132 }
1133
1134 tokio::time::sleep(Duration::from_millis(100)).await;
1136
1137 storage.cleanup_expired().await.unwrap();
1139
1140 for i in 0..10 {
1142 let retrieved = storage.get_kv(&format!("key-{}", i)).await.unwrap();
1143 assert!(retrieved.is_none());
1144 }
1145 }
1146
1147 #[tokio::test]
1148 async fn get_kv_ttl_reports_remaining_lifetime() {
1149 let storage = DashMapMemoryStorage::new();
1150 assert!(storage.tracks_kv_ttl());
1151 storage
1152 .store_kv("k:ttl", b"v", Some(Duration::from_secs(600)))
1153 .await
1154 .unwrap();
1155 storage.store_kv("k:forever", b"v", None).await.unwrap();
1156 let ttl = storage.get_kv_ttl("k:ttl").await.unwrap().unwrap();
1157 assert!(ttl > Duration::from_secs(590) && ttl <= Duration::from_secs(600));
1158 assert_eq!(storage.get_kv_ttl("k:missing").await.unwrap(), None);
1159 let _ = storage.get_kv_ttl("k:forever").await.unwrap();
1162 }
1163}