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(Debug, 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 TimestampedToken {
47 fn new(token: AuthToken, ttl: Option<Duration>) -> Self {
48 let now = chrono::Utc::now();
49 let expires_at = ttl.map(|d| now + chrono::Duration::from_std(d).unwrap());
50
51 Self {
52 token,
53 created_at: now,
54 expires_at,
55 }
56 }
57
58 fn is_expired(&self) -> bool {
59 self.expires_at
60 .map(|exp| chrono::Utc::now() > exp)
61 .unwrap_or(false)
62 }
63}
64
65impl TimestampedSession {
66 fn new(session: SessionData) -> Self {
67 Self {
68 session,
69 created_at: chrono::Utc::now(),
70 }
71 }
72
73 fn is_expired(&self) -> bool {
74 self.session.is_expired()
75 }
76}
77
78impl TimestampedValue {
79 fn new(data: Vec<u8>, ttl: Option<Duration>) -> Self {
80 let now = chrono::Utc::now();
81 let expires_at = ttl.map(|d| now + chrono::Duration::from_std(d).unwrap());
82
83 Self {
84 data,
85 created_at: now,
86 expires_at,
87 }
88 }
89
90 fn is_expired(&self) -> bool {
91 self.expires_at
92 .map(|exp| chrono::Utc::now() > exp)
93 .unwrap_or(false)
94 }
95}
96
97#[derive(Debug, Clone)]
99pub struct DashMapMemoryStorage {
100 tokens: DashMap<String, TimestampedToken>,
102 sessions: DashMap<String, TimestampedSession>,
103 kv_store: DashMap<String, TimestampedValue>,
104
105 access_token_to_id: DashMap<String, String>,
107 user_to_tokens: DashMap<String, Vec<String>>,
108 user_to_sessions: DashMap<String, Vec<String>>,
109
110 default_ttl: Option<Duration>,
112}
113
114impl Default for DashMapMemoryStorage {
115 fn default() -> Self {
116 Self::new()
117 }
118}
119
120impl DashMapMemoryStorage {
121 pub fn new() -> Self {
123 Self {
124 tokens: DashMap::new(),
125 sessions: DashMap::new(),
126 kv_store: DashMap::new(),
127 access_token_to_id: DashMap::new(),
128 user_to_tokens: DashMap::new(),
129 user_to_sessions: DashMap::new(),
130 default_ttl: None,
131 }
132 }
133
134 pub fn with_ttl(ttl: Duration) -> Self {
136 Self {
137 tokens: DashMap::new(),
138 sessions: DashMap::new(),
139 kv_store: DashMap::new(),
140 access_token_to_id: DashMap::new(),
141 user_to_tokens: DashMap::new(),
142 user_to_sessions: DashMap::new(),
143 default_ttl: Some(ttl),
144 }
145 }
146
147 fn create_audit_event(
149 &self,
150 event_type: AuditEventType,
151 user_id: &str,
152 resource_id: &str,
153 resource_type: &str,
154 outcome: EventOutcome,
155 details_str: Option<&str>,
156 ) -> AuditEvent {
157 let mut details = std::collections::HashMap::new();
158 if let Some(detail) = details_str {
159 details.insert("operation_details".to_string(), detail.to_string());
160 }
161 details.insert("resource_type".to_string(), resource_type.to_string());
162 details.insert("resource_id".to_string(), resource_id.to_string());
163
164 AuditEvent {
165 id: uuid::Uuid::new_v4().to_string(),
166 event_type: event_type.clone(),
167 timestamp: std::time::SystemTime::now(),
168 user_id: Some(user_id.to_string()),
169 session_id: None,
170 outcome,
171 risk_level: match &event_type {
172 AuditEventType::TokenRevoked | AuditEventType::TokenExpired => RiskLevel::Medium,
173 AuditEventType::SuspiciousActivity => RiskLevel::High,
174 _ => RiskLevel::Low,
175 },
176 description: format!(
177 "{:?} operation on {} {}",
178 event_type, resource_type, resource_id
179 ),
180 details,
181 request_metadata: RequestMetadata {
182 ip_address: None,
183 user_agent: None,
184 request_id: None,
185 endpoint: Some("storage".to_string()),
186 http_method: None,
187 geolocation: None,
188 device_info: None,
189 },
190 resource: Some(ResourceInfo {
191 resource_type: resource_type.to_string(),
192 resource_id: resource_id.to_string(),
193 resource_name: None,
194 attributes: std::collections::HashMap::new(),
195 }),
196 actor: ActorInfo {
197 actor_type: "storage_system".to_string(),
198 actor_id: user_id.to_string(),
199 actor_name: Some(user_id.to_string()),
200 roles: vec!["storage_user".to_string()],
201 },
202 correlation_id: None,
203 }
204 }
205
206 async fn log_storage_operation(
208 &self,
209 event_type: AuditEventType,
210 user_id: &str,
211 resource_id: &str,
212 resource_type: &str,
213 created_at: Option<chrono::DateTime<chrono::Utc>>,
214 outcome: EventOutcome,
215 ) {
216 let details = if let Some(created) = created_at {
217 let age = chrono::Utc::now().signed_duration_since(created);
218 format!(
219 "{:?} operation on {} {} (age: {} seconds)",
220 event_type,
221 resource_type,
222 resource_id,
223 age.num_seconds()
224 )
225 } else {
226 format!(
227 "{:?} operation on {} {}",
228 event_type, resource_type, resource_id
229 )
230 };
231
232 let audit_event = self.create_audit_event(
233 event_type,
234 user_id,
235 resource_id,
236 resource_type,
237 outcome,
238 Some(&details),
239 );
240
241 log::info!(
243 "STORAGE AUDIT: {}",
244 serde_json::to_string(&audit_event).unwrap_or_default()
245 );
246 }
247
248 pub fn get_storage_statistics(&self) -> std::collections::HashMap<String, serde_json::Value> {
250 let mut stats = std::collections::HashMap::new();
251 stats.insert(
252 "total_tokens".to_string(),
253 serde_json::Value::from(self.tokens.len()),
254 );
255 stats.insert(
256 "total_sessions".to_string(),
257 serde_json::Value::from(self.sessions.len()),
258 );
259 stats.insert(
260 "total_kv_pairs".to_string(),
261 serde_json::Value::from(self.kv_store.len()),
262 );
263 stats.insert(
264 "total_users_with_tokens".to_string(),
265 serde_json::Value::from(self.user_to_tokens.len()),
266 );
267 stats.insert(
268 "total_users_with_sessions".to_string(),
269 serde_json::Value::from(self.user_to_sessions.len()),
270 );
271 stats.insert(
272 "timestamp".to_string(),
273 serde_json::Value::from(chrono::Utc::now().to_rfc3339()),
274 );
275 stats
276 }
277
278 pub fn audit_token_ages(&self) -> Vec<(String, String, i64)> {
280 let mut aged_tokens = Vec::new();
281 let now = chrono::Utc::now();
282
283 for entry in self.tokens.iter() {
284 let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
285 aged_tokens.push((
286 entry.key().clone(),
287 entry.token.user_id.clone(),
288 age_seconds,
289 ));
290 }
291
292 aged_tokens.sort_by_key(|t| std::cmp::Reverse(t.2)); aged_tokens
294 }
295
296 pub fn audit_session_ages(&self) -> Vec<(String, String, i64)> {
298 let mut aged_sessions = Vec::new();
299 let now = chrono::Utc::now();
300
301 for entry in self.sessions.iter() {
302 let age_seconds = now.signed_duration_since(entry.created_at).num_seconds();
303 aged_sessions.push((
304 entry.key().clone(),
305 entry.session.user_id.clone(),
306 age_seconds,
307 ));
308 }
309
310 aged_sessions.sort_by_key(|t| std::cmp::Reverse(t.2)); aged_sessions
312 }
313
314 pub fn generate_audit_report(&self) -> std::collections::HashMap<String, serde_json::Value> {
316 let mut report = self.get_storage_statistics();
317
318 let token_ages = self.audit_token_ages();
319 let session_ages = self.audit_session_ages();
320
321 if !token_ages.is_empty() {
323 report.insert(
324 "oldest_token_age_seconds".to_string(),
325 serde_json::Value::from(token_ages[0].2),
326 );
327 report.insert(
328 "tokens_older_than_24h".to_string(),
329 serde_json::Value::from(
330 token_ages.iter().filter(|(_, _, age)| *age > 86400).count(),
331 ),
332 );
333 }
334
335 if !session_ages.is_empty() {
336 report.insert(
337 "oldest_session_age_seconds".to_string(),
338 serde_json::Value::from(session_ages[0].2),
339 );
340 report.insert(
341 "sessions_older_than_24h".to_string(),
342 serde_json::Value::from(
343 session_ages
344 .iter()
345 .filter(|(_, _, age)| *age > 86400)
346 .count(),
347 ),
348 );
349 }
350
351 report
352 }
353
354 fn add_token_to_user_index(&self, user_id: &str, token_id: &str) {
357 self.user_to_tokens
359 .entry(user_id.to_string())
360 .and_modify(|tokens| tokens.push(token_id.to_string()))
361 .or_insert_with(|| vec![token_id.to_string()]);
362 }
363
364 fn remove_token_from_user_index(&self, user_id: &str, token_id: &str) {
366 if let Some(mut entry) = self.user_to_tokens.get_mut(user_id) {
368 entry.retain(|id| id != token_id);
369 if entry.is_empty() {
370 drop(entry); self.user_to_tokens.remove(user_id);
372 }
373 }
374 }
375
376 fn add_session_to_user_index(&self, user_id: &str, session_id: &str) {
378 self.user_to_sessions
379 .entry(user_id.to_string())
380 .and_modify(|sessions| sessions.push(session_id.to_string()))
381 .or_insert_with(|| vec![session_id.to_string()]);
382 }
383
384 fn remove_session_from_user_index(&self, user_id: &str, session_id: &str) {
386 if let Some(mut entry) = self.user_to_sessions.get_mut(user_id) {
387 entry.retain(|id| id != session_id);
388 if entry.is_empty() {
389 drop(entry);
390 self.user_to_sessions.remove(user_id);
391 }
392 }
393 }
394
395 pub fn list_kv_keys_by_prefix(&self, prefix: &str) -> Vec<String> {
397 self.kv_store
398 .iter()
399 .filter_map(|entry| {
400 if entry.key().starts_with(prefix) {
401 Some(entry.key().clone())
402 } else {
403 None
404 }
405 })
406 .collect()
407 }
408}
409
410#[async_trait]
411impl AuthStorage for DashMapMemoryStorage {
412 async fn store_token(&self, token: &AuthToken) -> Result<()> {
413 let timestamped = TimestampedToken::new(token.clone(), self.default_ttl);
414 let created_at = timestamped.created_at;
415
416 self.tokens.insert(token.token_id.clone(), timestamped);
418
419 self.access_token_to_id
421 .insert(token.access_token.clone(), token.token_id.clone());
422
423 self.add_token_to_user_index(&token.user_id, &token.token_id);
425
426 self.log_storage_operation(
428 AuditEventType::LoginSuccess, &token.user_id,
430 &token.token_id,
431 "token",
432 Some(created_at),
433 EventOutcome::Success,
434 )
435 .await;
436
437 Ok(())
438 }
439
440 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
441 if let Some(timestamped) = self.tokens.get(token_id) {
443 let created_at = timestamped.created_at;
444 let user_id = timestamped.token.user_id.clone();
445
446 if timestamped.is_expired() {
447 drop(timestamped); self.tokens.remove(token_id); self.log_storage_operation(
452 AuditEventType::TokenExpired,
453 &user_id,
454 token_id,
455 "token",
456 Some(created_at),
457 EventOutcome::Failure,
458 )
459 .await;
460
461 return Ok(None);
462 }
463
464 let token = timestamped.token.clone();
465 drop(timestamped); self.log_storage_operation(
469 AuditEventType::LoginSuccess, &user_id,
471 token_id,
472 "token",
473 Some(created_at),
474 EventOutcome::Success,
475 )
476 .await;
477
478 Ok(Some(token))
479 } else {
480 Ok(None)
481 }
482 }
483
484 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
485 if let Some(token_id_entry) = self.access_token_to_id.get(access_token) {
487 let token_id = token_id_entry.clone(); drop(token_id_entry); self.get_token(&token_id).await } else {
491 Ok(None)
492 }
493 }
494
495 async fn update_token(&self, token: &AuthToken) -> Result<()> {
496 self.store_token(token).await
498 }
499
500 async fn delete_token(&self, token_id: &str) -> Result<()> {
501 let token_info = if let Some(timestamped) = self.tokens.get(token_id) {
503 Some((
504 timestamped.token.user_id.clone(),
505 timestamped.token.access_token.clone(),
506 timestamped.created_at,
507 ))
508 } else {
509 None
510 };
511
512 if let Some((user_id, access_token, created_at)) = token_info {
513 self.tokens.remove(token_id);
515 self.access_token_to_id.remove(&access_token);
516 self.remove_token_from_user_index(&user_id, token_id);
517
518 self.log_storage_operation(
520 AuditEventType::TokenRevoked,
521 &user_id,
522 token_id,
523 "token",
524 Some(created_at),
525 EventOutcome::Success,
526 )
527 .await;
528 }
529
530 Ok(())
531 }
532
533 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
534 let token_ids = if let Some(ids) = self.user_to_tokens.get(user_id) {
536 ids.clone() } else {
538 return Ok(Vec::new());
539 };
540
541 let mut tokens = Vec::new();
542 let mut expired_tokens = Vec::new();
543
544 for token_id in token_ids {
546 if let Some(timestamped) = self.tokens.get(&token_id) {
547 if timestamped.is_expired() {
548 expired_tokens.push(token_id);
549 } else {
550 tokens.push(timestamped.token.clone());
551 }
552 } else {
553 expired_tokens.push(token_id); }
555 }
556
557 for token_id in expired_tokens {
559 self.delete_token(&token_id).await?;
560 }
561
562 Ok(tokens)
563 }
564
565 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
566 let timestamped = TimestampedSession::new(data.clone());
567 let created_at = timestamped.created_at;
568
569 self.sessions.insert(session_id.to_string(), timestamped);
571
572 self.add_session_to_user_index(&data.user_id, session_id);
574
575 self.log_storage_operation(
577 AuditEventType::LoginSuccess, &data.user_id,
579 session_id,
580 "session",
581 Some(created_at),
582 EventOutcome::Success,
583 )
584 .await;
585
586 Ok(())
587 }
588
589 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
590 if let Some(timestamped) = self.sessions.get(session_id) {
592 let created_at = timestamped.created_at;
593 let user_id = timestamped.session.user_id.clone();
594
595 if timestamped.is_expired() {
596 drop(timestamped);
597 self.sessions.remove(session_id);
598
599 self.log_storage_operation(
601 AuditEventType::TokenExpired, &user_id,
603 session_id,
604 "session",
605 Some(created_at),
606 EventOutcome::Failure,
607 )
608 .await;
609
610 return Ok(None);
611 }
612
613 let session = timestamped.session.clone();
614 drop(timestamped);
615
616 self.log_storage_operation(
618 AuditEventType::LoginSuccess, &user_id,
620 session_id,
621 "session",
622 Some(created_at),
623 EventOutcome::Success,
624 )
625 .await;
626
627 Ok(Some(session))
628 } else {
629 Ok(None)
630 }
631 }
632
633 async fn delete_session(&self, session_id: &str) -> Result<()> {
634 let session_info = if let Some(timestamped) = self.sessions.get(session_id) {
636 Some((timestamped.session.user_id.clone(), timestamped.created_at))
637 } else {
638 None
639 };
640
641 if let Some((user_id, created_at)) = session_info {
642 self.sessions.remove(session_id);
643 self.remove_session_from_user_index(&user_id, session_id);
644
645 self.log_storage_operation(
647 AuditEventType::Logout,
648 &user_id,
649 session_id,
650 "session",
651 Some(created_at),
652 EventOutcome::Success,
653 )
654 .await;
655 }
656
657 Ok(())
658 }
659
660 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
661 let session_ids = if let Some(ids) = self.user_to_sessions.get(user_id) {
663 ids.clone()
664 } else {
665 return Ok(Vec::new());
666 };
667
668 let mut sessions = Vec::new();
669 let mut expired_sessions = Vec::new();
670
671 for session_id in session_ids {
673 if let Some(timestamped) = self.sessions.get(&session_id) {
674 if timestamped.is_expired() {
675 expired_sessions.push(session_id);
676 } else {
677 sessions.push(timestamped.session.clone());
678 }
679 } else {
680 expired_sessions.push(session_id);
681 }
682 }
683
684 for session_id in expired_sessions {
686 self.delete_session(&session_id).await?;
687 }
688
689 Ok(sessions)
690 }
691
692 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
693 let timestamped = TimestampedValue::new(value.to_vec(), ttl.or(self.default_ttl));
694 let created_at = timestamped.created_at;
695
696 self.kv_store.insert(key.to_string(), timestamped);
697
698 self.log_storage_operation(
700 AuditEventType::ConfigurationChanged, "system", key,
703 "kv_pair",
704 Some(created_at),
705 EventOutcome::Success,
706 )
707 .await;
708
709 Ok(())
710 }
711
712 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
713 if let Some(timestamped) = self.kv_store.get(key) {
715 let created_at = timestamped.created_at;
716
717 if timestamped.is_expired() {
718 drop(timestamped);
719 self.kv_store.remove(key);
720
721 self.log_storage_operation(
723 AuditEventType::TokenExpired, "system",
725 key,
726 "kv_pair",
727 Some(created_at),
728 EventOutcome::Failure,
729 )
730 .await;
731
732 return Ok(None);
733 }
734
735 let data = timestamped.data.clone();
736 drop(timestamped);
737
738 self.log_storage_operation(
740 AuditEventType::ConfigurationChanged, "system",
742 key,
743 "kv_pair",
744 Some(created_at),
745 EventOutcome::Success,
746 )
747 .await;
748
749 Ok(Some(data))
750 } else {
751 Ok(None)
752 }
753 }
754
755 async fn delete_kv(&self, key: &str) -> Result<()> {
756 let created_at = if let Some(timestamped) = self.kv_store.get(key) {
758 Some(timestamped.created_at)
759 } else {
760 None
761 };
762
763 self.kv_store.remove(key);
764
765 if let Some(created_at) = created_at {
766 self.log_storage_operation(
768 AuditEventType::ConfigurationChanged, "system",
770 key,
771 "kv_pair",
772 Some(created_at),
773 EventOutcome::Success,
774 )
775 .await;
776 }
777
778 Ok(())
779 }
780
781 async fn cleanup_expired(&self) -> Result<()> {
782 let mut expired_tokens = Vec::new();
784 let mut expired_sessions = Vec::new();
785 let mut expired_kvs = Vec::new();
786
787 for entry in self.tokens.iter() {
789 if entry.is_expired() {
790 expired_tokens.push(entry.key().clone());
791 }
792 }
793
794 for entry in self.sessions.iter() {
795 if entry.is_expired() {
796 expired_sessions.push(entry.key().clone());
797 }
798 }
799
800 for entry in self.kv_store.iter() {
801 if entry.is_expired() {
802 expired_kvs.push(entry.key().clone());
803 }
804 }
805
806 for token_id in expired_tokens {
808 self.delete_token(&token_id).await?;
809 }
810
811 for session_id in expired_sessions {
812 self.delete_session(&session_id).await?;
813 }
814
815 for key in expired_kvs {
816 self.delete_kv(&key).await?;
817 }
818
819 Ok(())
820 }
821
822 async fn count_active_sessions(&self) -> Result<u64> {
823 let mut count = 0;
824
825 for entry in self.sessions.iter() {
827 if !entry.is_expired() {
828 count += 1;
829 }
830 }
831
832 Ok(count)
833 }
834}
835
836#[cfg(test)]
837mod tests {
838 use super::*;
839 use crate::{testing::test_infrastructure::TestEnvironmentGuard, tokens::TokenMetadata};
840 use std::collections::HashMap;
841 use tokio::task::JoinSet;
842
843 #[tokio::test]
844 async fn test_basic_token_operations() {
845 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-test");
846 let storage = DashMapMemoryStorage::new();
847
848 let token = AuthToken {
849 token_id: "test-token".to_string(),
850 user_id: "test-user".to_string(),
851 access_token: "access-123".to_string(),
852 token_type: Some("bearer".to_string()),
853 subject: Some("test-user".to_string()),
854 issuer: Some("test-issuer".to_string()),
855 refresh_token: None,
856 issued_at: chrono::Utc::now(),
857 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
858 scopes: vec!["read".to_string()],
859 auth_method: "password".to_string(),
860 client_id: Some("test-client".to_string()),
861 user_profile: None,
862 permissions: vec!["read:data".to_string()],
863 roles: vec!["user".to_string()],
864 metadata: TokenMetadata::default(),
865 };
866
867 storage.store_token(&token).await.unwrap();
869
870 let retrieved = storage.get_token("test-token").await.unwrap().unwrap();
872 assert_eq!(retrieved.user_id, "test-user");
873
874 let retrieved = storage
876 .get_token_by_access_token("access-123")
877 .await
878 .unwrap()
879 .unwrap();
880 assert_eq!(retrieved.token_id, "test-token");
881
882 let user_tokens = storage.list_user_tokens("test-user").await.unwrap();
884 assert_eq!(user_tokens.len(), 1);
885
886 storage.delete_token("test-token").await.unwrap();
888 let retrieved = storage.get_token("test-token").await.unwrap();
889 assert!(retrieved.is_none());
890 }
891
892 #[tokio::test]
893 async fn test_session_operations() {
894 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-session-test");
895 let storage = DashMapMemoryStorage::new();
896
897 let session = SessionData {
898 session_id: "test-session".to_string(),
899 user_id: "test-user".to_string(),
900 created_at: chrono::Utc::now(),
901 last_activity: chrono::Utc::now(),
902 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
903 ip_address: Some("192.168.1.1".to_string()),
904 user_agent: Some("test-agent".to_string()),
905 data: HashMap::new(),
906 };
907
908 storage
910 .store_session("test-session", &session)
911 .await
912 .unwrap();
913
914 let retrieved = storage.get_session("test-session").await.unwrap().unwrap();
916 assert_eq!(retrieved.user_id, "test-user");
917
918 let user_sessions = storage.list_user_sessions("test-user").await.unwrap();
920 assert_eq!(user_sessions.len(), 1);
921
922 storage.delete_session("test-session").await.unwrap();
924 let retrieved = storage.get_session("test-session").await.unwrap();
925 assert!(retrieved.is_none());
926 }
927
928 #[tokio::test]
929 async fn test_kv_operations() {
930 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-kv-test");
931 let storage = DashMapMemoryStorage::new();
932
933 let key = "test-key";
934 let value = b"test-value";
935
936 storage
938 .store_kv(key, value, Some(Duration::from_secs(3600)))
939 .await
940 .unwrap();
941
942 let retrieved = storage.get_kv(key).await.unwrap().unwrap();
944 assert_eq!(retrieved, value);
945
946 storage.delete_kv(key).await.unwrap();
948 let retrieved = storage.get_kv(key).await.unwrap();
949 assert!(retrieved.is_none());
950 }
951
952 #[tokio::test]
953 async fn test_concurrent_operations_no_deadlock() {
954 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-concurrent-test");
955 let storage = std::sync::Arc::new(DashMapMemoryStorage::new());
956
957 let mut join_set = JoinSet::new();
958
959 for i in 0..10 {
961 let storage = storage.clone();
962 join_set.spawn(async move {
963 for j in 0..50 {
964 let token = AuthToken {
965 token_id: format!("token-{}-{}", i, j),
966 user_id: format!("user-{}", i % 3), access_token: format!("access-{}-{}", i, j),
968 token_type: Some("bearer".to_string()),
969 subject: Some(format!("user-{}", i % 3)),
970 issuer: Some("test-issuer".to_string()),
971 refresh_token: None,
972 issued_at: chrono::Utc::now(),
973 expires_at: chrono::Utc::now() + chrono::Duration::hours(1),
974 scopes: vec!["read".to_string()],
975 auth_method: "password".to_string(),
976 client_id: Some("test-client".to_string()),
977 user_profile: None,
978 permissions: vec!["read:data".to_string()],
979 roles: vec!["user".to_string()],
980 metadata: TokenMetadata::default(),
981 };
982
983 storage.store_token(&token).await.unwrap();
985
986 let _user_tokens = storage.list_user_tokens(&token.user_id).await.unwrap();
988
989 let _retrieved = storage
991 .get_token_by_access_token(&token.access_token)
992 .await
993 .unwrap();
994 }
995 });
996 }
997
998 while join_set.join_next().await.is_some() {}
1000
1001 println!("✅ Concurrent operations test passed - no deadlocks detected!");
1002 }
1003
1004 #[tokio::test]
1005 async fn test_ttl_expiration() {
1006 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-ttl-test");
1007 let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(100));
1008
1009 storage
1011 .store_kv("expiring-key", b"expiring-value", None)
1012 .await
1013 .unwrap();
1014
1015 let retrieved = storage.get_kv("expiring-key").await.unwrap();
1017 assert!(retrieved.is_some());
1018
1019 tokio::time::sleep(Duration::from_millis(150)).await;
1021
1022 let retrieved = storage.get_kv("expiring-key").await.unwrap();
1024 assert!(retrieved.is_none());
1025 }
1026
1027 #[tokio::test]
1028 async fn test_cleanup_expired() {
1029 let _env = TestEnvironmentGuard::new().with_jwt_secret("dashmap-cleanup-test");
1030 let storage = DashMapMemoryStorage::with_ttl(Duration::from_millis(50));
1031
1032 for i in 0..10 {
1034 storage
1035 .store_kv(&format!("key-{}", i), b"value", None)
1036 .await
1037 .unwrap();
1038 }
1039
1040 tokio::time::sleep(Duration::from_millis(100)).await;
1042
1043 storage.cleanup_expired().await.unwrap();
1045
1046 for i in 0..10 {
1048 let retrieved = storage.get_kv(&format!("key-{}", i)).await.unwrap();
1049 assert!(retrieved.is_none());
1050 }
1051 }
1052}