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