1use crate::errors::Result;
4use crate::tokens::AuthToken;
5use async_trait::async_trait;
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8use std::sync::{Arc, RwLock};
9use std::time::Duration;
10
11#[cfg(feature = "redis-storage")]
12use crate::errors::StorageError;
13
14#[async_trait]
76pub trait AuthStorage: Send + Sync {
77 async fn store_tokens_bulk(&self, tokens: &[AuthToken]) -> Result<()> {
79 for token in tokens {
80 self.store_token(token).await?;
81 }
82 Ok(())
83 }
84
85 async fn delete_tokens_bulk(&self, token_ids: &[String]) -> Result<()> {
87 for token_id in token_ids {
88 self.delete_token(token_id).await?;
89 }
90 Ok(())
91 }
92
93 async fn store_sessions_bulk(&self, sessions: &[(String, SessionData)]) -> Result<()> {
95 for (session_id, data) in sessions {
96 self.store_session(session_id, data).await?;
97 }
98 Ok(())
99 }
100
101 async fn delete_sessions_bulk(&self, session_ids: &[String]) -> Result<()> {
103 for session_id in session_ids {
104 self.delete_session(session_id).await?;
105 }
106 Ok(())
107 }
108 async fn store_token(&self, token: &AuthToken) -> Result<()>;
110
111 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>>;
113
114 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>>;
116
117 async fn update_token(&self, token: &AuthToken) -> Result<()>;
119
120 async fn delete_token(&self, token_id: &str) -> Result<()>;
122
123 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>>;
125
126 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()>;
128
129 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>>;
131
132 async fn delete_session(&self, session_id: &str) -> Result<()>;
134
135 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>>;
137
138 async fn count_active_sessions(&self) -> Result<u64>;
140
141 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()>;
143
144 async fn store_kv_if_absent(
152 &self,
153 key: &str,
154 value: &[u8],
155 ttl: Option<Duration>,
156 ) -> Result<bool> {
157 if self.get_kv(key).await?.is_some() {
158 return Ok(false);
159 }
160 self.store_kv(key, value, ttl).await?;
161 Ok(true)
162 }
163
164 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>>;
166
167 async fn get_kv_ttl(&self, _key: &str) -> Result<Option<Duration>> {
178 Ok(None)
179 }
180
181 fn tracks_kv_ttl(&self) -> bool {
188 false
189 }
190
191 fn encrypts_kv_at_rest(&self) -> bool {
197 false
198 }
199
200 async fn delete_kv(&self, key: &str) -> Result<()>;
202
203 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
209 tracing::warn!(
210 "list_kv_keys called on a storage backend that does not override it — returning empty"
211 );
212 Ok(Vec::new())
213 }
214
215 async fn cleanup_expired(&self) -> Result<()>;
217}
218
219#[async_trait]
236impl AuthStorage for Arc<dyn AuthStorage> {
237 async fn store_tokens_bulk(&self, tokens: &[AuthToken]) -> Result<()> {
238 (**self).store_tokens_bulk(tokens).await
239 }
240
241 async fn delete_tokens_bulk(&self, token_ids: &[String]) -> Result<()> {
242 (**self).delete_tokens_bulk(token_ids).await
243 }
244
245 async fn store_sessions_bulk(&self, sessions: &[(String, SessionData)]) -> Result<()> {
246 (**self).store_sessions_bulk(sessions).await
247 }
248
249 async fn delete_sessions_bulk(&self, session_ids: &[String]) -> Result<()> {
250 (**self).delete_sessions_bulk(session_ids).await
251 }
252
253 async fn store_token(&self, token: &AuthToken) -> Result<()> {
254 (**self).store_token(token).await
255 }
256
257 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
258 (**self).get_token(token_id).await
259 }
260
261 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
262 (**self).get_token_by_access_token(access_token).await
263 }
264
265 async fn update_token(&self, token: &AuthToken) -> Result<()> {
266 (**self).update_token(token).await
267 }
268
269 async fn delete_token(&self, token_id: &str) -> Result<()> {
270 (**self).delete_token(token_id).await
271 }
272
273 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
274 (**self).list_user_tokens(user_id).await
275 }
276
277 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
278 (**self).store_session(session_id, data).await
279 }
280
281 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
282 (**self).get_session(session_id).await
283 }
284
285 async fn delete_session(&self, session_id: &str) -> Result<()> {
286 (**self).delete_session(session_id).await
287 }
288
289 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
290 (**self).list_user_sessions(user_id).await
291 }
292
293 async fn count_active_sessions(&self) -> Result<u64> {
294 (**self).count_active_sessions().await
295 }
296
297 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
298 (**self).store_kv(key, value, ttl).await
299 }
300
301 async fn store_kv_if_absent(
302 &self,
303 key: &str,
304 value: &[u8],
305 ttl: Option<Duration>,
306 ) -> Result<bool> {
307 (**self).store_kv_if_absent(key, value, ttl).await
308 }
309
310 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
311 (**self).get_kv(key).await
312 }
313
314 async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
315 (**self).get_kv_ttl(key).await
316 }
317
318 fn tracks_kv_ttl(&self) -> bool {
319 (**self).tracks_kv_ttl()
320 }
321
322 async fn delete_kv(&self, key: &str) -> Result<()> {
323 (**self).delete_kv(key).await
324 }
325
326 fn encrypts_kv_at_rest(&self) -> bool {
327 (**self).encrypts_kv_at_rest()
328 }
329
330 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
331 (**self).list_kv_keys(prefix).await
332 }
333
334 async fn cleanup_expired(&self) -> Result<()> {
335 (**self).cleanup_expired().await
336 }
337}
338
339#[derive(Debug, Clone, Serialize, Deserialize)]
365pub struct SessionData {
366 pub session_id: String,
368
369 pub user_id: String,
371
372 pub created_at: chrono::DateTime<chrono::Utc>,
374
375 pub expires_at: chrono::DateTime<chrono::Utc>,
377
378 pub last_activity: chrono::DateTime<chrono::Utc>,
380
381 pub ip_address: Option<String>,
383
384 pub user_agent: Option<String>,
386
387 pub data: HashMap<String, serde_json::Value>,
389}
390
391#[derive(Debug, Clone)]
406pub struct MemoryStorage {
407 inner: crate::storage::dashmap_memory::DashMapMemoryStorage,
409 roles: Arc<RwLock<HashMap<String, crate::authorization::AbacRole>>>,
411 user_roles: Arc<RwLock<Vec<crate::authorization::UserRole>>>,
412}
413
414#[cfg(feature = "redis-storage")]
416#[derive(Debug, Clone)]
417pub struct RedisStorage {
418 client: redis::Client,
419 key_prefix: String,
420}
421
422impl Default for MemoryStorage {
423 fn default() -> Self {
424 Self::new()
425 }
426}
427
428impl MemoryStorage {
429 pub fn new() -> Self {
431 Self {
432 inner: crate::storage::dashmap_memory::DashMapMemoryStorage::new(),
433 roles: Arc::new(RwLock::new(HashMap::new())),
434 user_roles: Arc::new(RwLock::new(Vec::new())),
435 }
436 }
437}
438#[async_trait::async_trait]
440impl crate::authorization::AuthorizationStorage for MemoryStorage {
441 async fn store_role(&self, role: &crate::authorization::AbacRole) -> crate::errors::Result<()> {
442 let mut roles = self.roles.write().map_err(|_| {
443 crate::errors::AuthError::internal(
444 "Lock poisoned — a prior thread panicked while holding this lock",
445 )
446 })?;
447 roles.insert(role.id.clone(), role.clone());
448 Ok(())
449 }
450
451 async fn get_role(
452 &self,
453 role_id: &str,
454 ) -> crate::errors::Result<Option<crate::authorization::AbacRole>> {
455 let roles = self.roles.read().map_err(|_| {
456 crate::errors::AuthError::internal(
457 "Lock poisoned — a prior thread panicked while holding this lock",
458 )
459 })?;
460 Ok(roles.get(role_id).cloned())
461 }
462
463 async fn update_role(
464 &self,
465 role: &crate::authorization::AbacRole,
466 ) -> crate::errors::Result<()> {
467 let mut roles = self.roles.write().map_err(|_| {
468 crate::errors::AuthError::internal(
469 "Lock poisoned — a prior thread panicked while holding this lock",
470 )
471 })?;
472 roles.insert(role.id.clone(), role.clone());
473 Ok(())
474 }
475
476 async fn delete_role(&self, role_id: &str) -> crate::errors::Result<()> {
477 let mut roles = self.roles.write().map_err(|_| {
478 crate::errors::AuthError::internal(
479 "Lock poisoned — a prior thread panicked while holding this lock",
480 )
481 })?;
482 roles.remove(role_id);
483 Ok(())
484 }
485
486 async fn list_roles(&self) -> crate::errors::Result<Vec<crate::authorization::AbacRole>> {
487 let roles = self.roles.read().map_err(|_| {
488 crate::errors::AuthError::internal(
489 "Lock poisoned — a prior thread panicked while holding this lock",
490 )
491 })?;
492 Ok(roles.values().cloned().collect())
493 }
494
495 async fn assign_role(
496 &self,
497 user_role: &crate::authorization::UserRole,
498 ) -> crate::errors::Result<()> {
499 let mut user_roles = self.user_roles.write().map_err(|_| {
500 crate::errors::AuthError::internal(
501 "Lock poisoned — a prior thread panicked while holding this lock",
502 )
503 })?;
504 user_roles.push(user_role.clone());
505 Ok(())
506 }
507
508 async fn remove_role(&self, user_id: &str, role_id: &str) -> crate::errors::Result<()> {
509 let mut user_roles = self.user_roles.write().map_err(|_| {
510 crate::errors::AuthError::internal(
511 "Lock poisoned — a prior thread panicked while holding this lock",
512 )
513 })?;
514 user_roles.retain(|ur| ur.user_id != user_id || ur.role_id != role_id);
515 Ok(())
516 }
517
518 async fn get_user_roles(
519 &self,
520 user_id: &str,
521 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
522 let user_roles = self.user_roles.read().map_err(|_| {
523 crate::errors::AuthError::internal(
524 "Lock poisoned — a prior thread panicked while holding this lock",
525 )
526 })?;
527 Ok(user_roles
528 .iter()
529 .filter(|ur| ur.user_id == user_id)
530 .cloned()
531 .collect())
532 }
533
534 async fn get_role_users(
535 &self,
536 role_id: &str,
537 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
538 let user_roles = self.user_roles.read().map_err(|_| {
539 crate::errors::AuthError::internal(
540 "Lock poisoned — a prior thread panicked while holding this lock",
541 )
542 })?;
543 Ok(user_roles
544 .iter()
545 .filter(|ur| ur.role_id == role_id)
546 .cloned()
547 .collect())
548 }
549}
550
551#[async_trait]
552impl AuthStorage for MemoryStorage {
553 async fn store_token(&self, token: &AuthToken) -> Result<()> {
554 self.inner.store_token(token).await
556 }
557
558 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
559 self.inner.get_token(token_id).await
561 }
562
563 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
564 self.inner.get_token_by_access_token(access_token).await
566 }
567
568 async fn update_token(&self, token: &AuthToken) -> Result<()> {
569 self.inner.update_token(token).await
571 }
572
573 async fn delete_token(&self, token_id: &str) -> Result<()> {
574 self.inner.delete_token(token_id).await
576 }
577
578 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
579 self.inner.list_user_tokens(user_id).await
581 }
582
583 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
584 self.inner.store_session(session_id, data).await
586 }
587
588 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
589 self.inner.get_session(session_id).await
591 }
592
593 async fn delete_session(&self, session_id: &str) -> Result<()> {
594 self.inner.delete_session(session_id).await
596 }
597
598 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
599 self.inner.list_user_sessions(user_id).await
601 }
602
603 async fn count_active_sessions(&self) -> Result<u64> {
604 self.inner.count_active_sessions().await
606 }
607
608 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
609 self.inner.store_kv(key, value, ttl).await
611 }
612
613 async fn store_kv_if_absent(
614 &self,
615 key: &str,
616 value: &[u8],
617 ttl: Option<Duration>,
618 ) -> Result<bool> {
619 self.inner.store_kv_if_absent(key, value, ttl).await
620 }
621
622 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
623 self.inner.get_kv(key).await
625 }
626
627 async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
628 self.inner.get_kv_ttl(key).await
629 }
630
631 fn tracks_kv_ttl(&self) -> bool {
632 self.inner.tracks_kv_ttl()
633 }
634
635 async fn delete_kv(&self, key: &str) -> Result<()> {
636 self.inner.delete_kv(key).await
638 }
639
640 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
641 Ok(self.inner.list_kv_keys_by_prefix(prefix))
642 }
643
644 async fn cleanup_expired(&self) -> Result<()> {
645 self.inner.cleanup_expired().await
647 }
648}
649
650#[cfg(feature = "redis-storage")]
651impl RedisStorage {
652 pub fn new(redis_url: &str, key_prefix: impl Into<String>) -> Result<Self> {
654 let client = redis::Client::open(redis_url).map_err(|e| {
655 StorageError::connection_failed(format!("Redis connection failed: {e}"))
656 })?;
657
658 Ok(Self {
659 client,
660 key_prefix: key_prefix.into(),
661 })
662 }
663
664 async fn get_connection(&self) -> Result<redis::aio::MultiplexedConnection> {
666 self.client
667 .get_multiplexed_async_connection()
668 .await
669 .map_err(|e| {
670 StorageError::connection_failed(format!("Failed to get Redis connection: {e}"))
671 .into()
672 })
673 }
674
675 fn key(&self, suffix: &str) -> String {
677 format!("{}{}", self.key_prefix, suffix)
678 }
679}
680
681#[cfg(feature = "redis-storage")]
682#[async_trait]
683impl AuthStorage for RedisStorage {
684 async fn store_token(&self, token: &AuthToken) -> Result<()> {
685 let mut conn = self.get_connection().await?;
686 let token_json = serde_json::to_string(token)
687 .map_err(|e| StorageError::serialization(format!("Token serialization failed: {e}")))?;
688
689 let token_key = self.key(&format!("token:{}", token.token_id));
690 let access_token_key = self.key(&format!("access_token:{}", token.access_token));
691 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
692
693 let ttl = token.time_until_expiry().as_secs().max(1);
695
696 let _: () = redis::cmd("SETEX")
698 .arg(&token_key)
699 .arg(ttl)
700 .arg(&token_json)
701 .query_async(&mut conn)
702 .await
703 .map_err(|e| StorageError::operation_failed(format!("Failed to store token: {e}")))?;
704
705 let _: () = redis::cmd("SETEX")
707 .arg(&access_token_key)
708 .arg(ttl)
709 .arg(&token.token_id)
710 .query_async(&mut conn)
711 .await
712 .map_err(|e| {
713 StorageError::operation_failed(format!("Failed to store access token mapping: {e}"))
714 })?;
715
716 let _: () = redis::cmd("SADD")
718 .arg(&user_tokens_key)
719 .arg(&token.token_id)
720 .query_async(&mut conn)
721 .await
722 .map_err(|e| {
723 StorageError::operation_failed(format!("Failed to add token to user set: {e}"))
724 })?;
725
726 Ok(())
727 }
728
729 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
730 let mut conn = self.get_connection().await?;
731 let token_key = self.key(&format!("token:{token_id}"));
732
733 let token_json: Option<String> = redis::cmd("GET")
734 .arg(&token_key)
735 .query_async(&mut conn)
736 .await
737 .map_err(|e| StorageError::operation_failed(format!("Failed to get token: {e}")))?;
738
739 if let Some(json) = token_json {
740 let token: AuthToken = serde_json::from_str(&json).map_err(|e| {
741 StorageError::serialization(format!("Token deserialization failed: {e}"))
742 })?;
743 Ok(Some(token))
744 } else {
745 Ok(None)
746 }
747 }
748
749 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
750 let mut conn = self.get_connection().await?;
751 let access_token_key = self.key(&format!("access_token:{access_token}"));
752
753 let token_id: Option<String> = redis::cmd("GET")
754 .arg(&access_token_key)
755 .query_async(&mut conn)
756 .await
757 .map_err(|e| {
758 StorageError::operation_failed(format!("Failed to get access token mapping: {e}"))
759 })?;
760
761 if let Some(token_id) = token_id {
762 self.get_token(&token_id).await
763 } else {
764 Ok(None)
765 }
766 }
767
768 async fn update_token(&self, token: &AuthToken) -> Result<()> {
769 self.store_token(token).await
771 }
772
773 async fn delete_token(&self, token_id: &str) -> Result<()> {
774 let mut conn = self.get_connection().await?;
775
776 if let Some(token) = self.get_token(token_id).await? {
778 let token_key = self.key(&format!("token:{token_id}"));
779 let access_token_key = self.key(&format!("access_token:{}", token.access_token));
780 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
781
782 let _: () = redis::cmd("DEL")
784 .arg(&token_key)
785 .query_async(&mut conn)
786 .await
787 .map_err(|e| {
788 StorageError::operation_failed(format!("Failed to delete token: {e}"))
789 })?;
790
791 let _: () = redis::cmd("DEL")
793 .arg(&access_token_key)
794 .query_async(&mut conn)
795 .await
796 .map_err(|e| {
797 StorageError::operation_failed(format!(
798 "Failed to delete access token mapping: {e}"
799 ))
800 })?;
801
802 let _: () = redis::cmd("SREM")
804 .arg(&user_tokens_key)
805 .arg(token_id)
806 .query_async(&mut conn)
807 .await
808 .map_err(|e| {
809 StorageError::operation_failed(format!(
810 "Failed to remove token from user set: {e}"
811 ))
812 })?;
813 }
814
815 Ok(())
816 }
817
818 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
819 let mut conn = self.get_connection().await?;
820 let user_tokens_key = self.key(&format!("user_tokens:{user_id}"));
821
822 let token_ids: Vec<String> = redis::cmd("SMEMBERS")
823 .arg(&user_tokens_key)
824 .query_async(&mut conn)
825 .await
826 .map_err(|e| {
827 StorageError::operation_failed(format!("Failed to get user tokens: {e}"))
828 })?;
829
830 let mut tokens = Vec::new();
831 for token_id in token_ids {
832 if let Some(token) = self.get_token(&token_id).await? {
833 tokens.push(token);
834 }
835 }
836
837 Ok(tokens)
838 }
839
840 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
841 let mut conn = self.get_connection().await?;
842 let session_key = self.key(&format!("session:{session_id}"));
843
844 let session_json = serde_json::to_string(data).map_err(|e| {
845 StorageError::serialization(format!("Session serialization failed: {e}"))
846 })?;
847
848 let ttl = (data.expires_at - chrono::Utc::now()).num_seconds().max(1);
849
850 let _: () = redis::cmd("SETEX")
851 .arg(&session_key)
852 .arg(ttl)
853 .arg(&session_json)
854 .query_async(&mut conn)
855 .await
856 .map_err(|e| StorageError::operation_failed(format!("Failed to store session: {e}")))?;
857
858 Ok(())
859 }
860
861 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
862 let mut conn = self.get_connection().await?;
863 let session_key = self.key(&format!("session:{session_id}"));
864
865 let session_json: Option<String> = redis::cmd("GET")
866 .arg(&session_key)
867 .query_async(&mut conn)
868 .await
869 .map_err(|e| StorageError::operation_failed(format!("Failed to get session: {e}")))?;
870
871 if let Some(json) = session_json {
872 let session: SessionData = serde_json::from_str(&json).map_err(|e| {
873 StorageError::serialization(format!("Session deserialization failed: {e}"))
874 })?;
875 Ok(Some(session))
876 } else {
877 Ok(None)
878 }
879 }
880
881 async fn delete_session(&self, session_id: &str) -> Result<()> {
882 let mut conn = self.get_connection().await?;
883 let session_key = self.key(&format!("session:{session_id}"));
884
885 let _: () = redis::cmd("DEL")
886 .arg(&session_key)
887 .query_async(&mut conn)
888 .await
889 .map_err(|e| {
890 StorageError::operation_failed(format!("Failed to delete session: {e}"))
891 })?;
892
893 Ok(())
894 }
895
896 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
897 let mut conn = self.get_connection().await?;
898 let pattern = self.key("session:*");
899
900 let keys: Vec<String> = redis::cmd("KEYS")
902 .arg(&pattern)
903 .query_async(&mut conn)
904 .await
905 .map_err(|e| StorageError::operation_failed(format!("Failed to scan sessions: {e}")))?;
906
907 let mut user_sessions = Vec::new();
908
909 for key in keys {
911 if let Ok(session_json) = redis::cmd("GET")
912 .arg(&key)
913 .query_async::<Option<String>>(&mut conn)
914 .await
915 && let Some(session_json) = session_json
916 && let Ok(session) = serde_json::from_str::<SessionData>(&session_json)
917 && session.user_id == user_id
918 && !session.is_expired()
919 {
920 user_sessions.push(session);
921 }
922 }
923
924 Ok(user_sessions)
925 }
926
927 async fn store_kv_if_absent(
928 &self,
929 key: &str,
930 value: &[u8],
931 ttl: Option<Duration>,
932 ) -> Result<bool> {
933 let mut conn = self.get_connection().await?;
934 let storage_key = self.key(&format!("kv:{key}"));
935 let mut cmd = redis::cmd("SET");
937 cmd.arg(&storage_key).arg(value).arg("NX");
938 if let Some(ttl) = ttl {
939 let millis = u64::try_from(ttl.as_millis()).unwrap_or(u64::MAX).max(1);
940 cmd.arg("PX").arg(millis);
941 }
942 let reply: Option<String> = cmd.query_async(&mut conn).await.map_err(|e| {
943 StorageError::operation_failed(format!("Failed to store KV if absent: {e}"))
944 })?;
945 Ok(reply.is_some())
946 }
947
948 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
949 let mut conn = self.get_connection().await?;
950 let storage_key = self.key(&format!("kv:{key}"));
951
952 if let Some(ttl) = ttl {
953 let millis = u64::try_from(ttl.as_millis()).unwrap_or(u64::MAX).max(1);
956 let _: () = redis::cmd("PSETEX")
957 .arg(&storage_key)
958 .arg(millis)
959 .arg(value)
960 .query_async(&mut conn)
961 .await
962 .map_err(|e| {
963 StorageError::operation_failed(format!("Failed to store KV with TTL: {e}"))
964 })?;
965 } else {
966 let _: () = redis::cmd("SET")
967 .arg(&storage_key)
968 .arg(value)
969 .query_async(&mut conn)
970 .await
971 .map_err(|e| StorageError::operation_failed(format!("Failed to store KV: {e}")))?;
972 }
973
974 Ok(())
975 }
976
977 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
978 let mut conn = self.get_connection().await?;
979 let storage_key = self.key(&format!("kv:{key}"));
980
981 let value: Option<Vec<u8>> = redis::cmd("GET")
982 .arg(&storage_key)
983 .query_async(&mut conn)
984 .await
985 .map_err(|e| StorageError::operation_failed(format!("Failed to get KV: {e}")))?;
986
987 Ok(value)
988 }
989
990 async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
991 let mut conn = self.get_connection().await?;
992 let storage_key = self.key(&format!("kv:{key}"));
993
994 let millis: i64 = redis::cmd("PTTL")
996 .arg(&storage_key)
997 .query_async(&mut conn)
998 .await
999 .map_err(|e| StorageError::operation_failed(format!("Failed to get KV TTL: {e}")))?;
1000
1001 Ok(u64::try_from(millis)
1002 .ok()
1003 .filter(|millis| *millis > 0)
1004 .map(Duration::from_millis))
1005 }
1006
1007 fn tracks_kv_ttl(&self) -> bool {
1008 true
1009 }
1010
1011 async fn delete_kv(&self, key: &str) -> Result<()> {
1012 let mut conn = self.get_connection().await?;
1013 let storage_key = self.key(&format!("kv:{key}"));
1014
1015 let _: () = redis::cmd("DEL")
1016 .arg(&storage_key)
1017 .query_async(&mut conn)
1018 .await
1019 .map_err(|e| StorageError::operation_failed(format!("Failed to delete KV: {e}")))?;
1020
1021 Ok(())
1022 }
1023
1024 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
1025 let mut conn = self.get_connection().await?;
1026 let pattern = self.key(&format!("kv:{prefix}*"));
1027 let keys: Vec<String> = redis::cmd("KEYS")
1028 .arg(&pattern)
1029 .query_async(&mut conn)
1030 .await
1031 .map_err(|e| StorageError::operation_failed(format!("Failed to list KV keys: {e}")))?;
1032
1033 Ok(keys
1034 .into_iter()
1035 .filter_map(|key| key.strip_prefix(&self.key_prefix).map(str::to_string))
1036 .filter_map(|key| key.strip_prefix("kv:").map(str::to_string))
1037 .collect())
1038 }
1039
1040 async fn cleanup_expired(&self) -> Result<()> {
1041 Ok(())
1043 }
1044
1045 async fn count_active_sessions(&self) -> Result<u64> {
1046 let mut conn = self.get_connection().await?;
1047 let pattern = self.key("session:*");
1048
1049 let keys: Vec<String> = redis::cmd("KEYS")
1051 .arg(&pattern)
1052 .query_async(&mut conn)
1053 .await
1054 .map_err(|e| StorageError::operation_failed(format!("Failed to scan sessions: {e}")))?;
1055
1056 let mut active_count = 0u64;
1058 for key in keys {
1059 let ttl: i64 = redis::cmd("TTL")
1060 .arg(&key)
1061 .query_async(&mut conn)
1062 .await
1063 .map_err(|e| StorageError::operation_failed(format!("Failed to check TTL: {e}")))?;
1064
1065 if ttl > 0 || ttl == -1 {
1069 active_count += 1;
1070 }
1071 }
1072
1073 Ok(active_count)
1074 }
1075}
1076
1077impl SessionData {
1078 pub fn new(
1091 session_id: impl Into<String>,
1092 user_id: impl Into<String>,
1093 expires_in: Duration,
1094 ) -> Self {
1095 let now = chrono::Utc::now();
1096
1097 Self {
1098 session_id: session_id.into(),
1099 user_id: user_id.into(),
1100 created_at: now,
1101 expires_at: now
1102 + chrono::Duration::from_std(expires_in).unwrap_or(chrono::Duration::hours(1)),
1103 last_activity: now,
1104 ip_address: None,
1105 user_agent: None,
1106 data: HashMap::new(),
1107 }
1108 }
1109
1110 pub fn is_expired(&self) -> bool {
1112 chrono::Utc::now() > self.expires_at
1113 }
1114
1115 pub fn time_until_expiry(&self) -> std::time::Duration {
1120 let remaining = self.expires_at - chrono::Utc::now();
1121 remaining.to_std().unwrap_or(std::time::Duration::ZERO)
1122 }
1123
1124 pub fn is_active(&self) -> bool {
1126 !self.is_expired()
1127 }
1128
1129 pub fn update_activity(&mut self) {
1131 self.last_activity = chrono::Utc::now();
1132 }
1133
1134 pub fn with_metadata(mut self, ip_address: Option<String>, user_agent: Option<String>) -> Self {
1136 self.ip_address = ip_address;
1137 self.user_agent = user_agent;
1138 self
1139 }
1140
1141 pub fn ip_address(mut self, ip: impl Into<String>) -> Self {
1143 self.ip_address = Some(ip.into());
1144 self
1145 }
1146
1147 pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
1149 self.user_agent = Some(ua.into());
1150 self
1151 }
1152
1153 pub fn with_data(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
1155 self.data.insert(key.into(), value);
1156 self
1157 }
1158
1159 pub fn set_data(&mut self, key: impl Into<String>, value: serde_json::Value) {
1161 self.data.insert(key.into(), value);
1162 }
1163
1164 pub fn get_data(&self, key: &str) -> Option<&serde_json::Value> {
1166 self.data.get(key)
1167 }
1168}
1169
1170#[async_trait]
1172impl crate::audit::AuditStorage for MemoryStorage {
1173 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1174 let json_data = serde_json::to_vec(event).map_err(|e| {
1176 crate::errors::AuthError::internal(format!("Failed to serialize audit event: {}", e))
1177 })?;
1178
1179 let key = format!("audit_event_{}", event.id);
1180 self.store_kv(&key, &json_data, None).await
1181 }
1182
1183 async fn query_events(
1184 &self,
1185 query: &crate::audit::AuditQuery,
1186 ) -> Result<Vec<crate::audit::AuditEvent>> {
1187 let all_keys = self.list_kv_keys("audit_event_").await?;
1189 let mut events = Vec::new();
1190
1191 for key in all_keys {
1192 if let Some(data) = self.get_kv(&key).await?
1193 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1194 {
1195 let mut include = true;
1197
1198 if let Some(ref time_range) = query.time_range
1199 && (event.timestamp < time_range.start || event.timestamp > time_range.end)
1200 {
1201 include = false;
1202 }
1203
1204 if let Some(ref event_types) = query.event_types
1205 && !event_types.contains(&event.event_type)
1206 {
1207 include = false;
1208 }
1209
1210 if let Some(ref user_id) = query.user_id
1211 && event.user_id.as_ref() != Some(user_id)
1212 {
1213 include = false;
1214 }
1215
1216 if include {
1217 events.push(event);
1218 }
1219 }
1220 }
1221
1222 events.sort_by(|a, b| match query.sort_order {
1224 crate::audit::SortOrder::TimestampAsc => a.timestamp.cmp(&b.timestamp),
1225 crate::audit::SortOrder::TimestampDesc => b.timestamp.cmp(&a.timestamp),
1226 crate::audit::SortOrder::RiskLevelDesc => b.risk_level.cmp(&a.risk_level),
1227 });
1228
1229 if let Some(limit) = query.limit {
1230 events.truncate(limit as usize);
1231 }
1232 Ok(events)
1233 }
1234
1235 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1236 let key = format!("audit_event_{}", event_id);
1237 if let Some(data) = self.get_kv(&key).await? {
1238 let event = serde_json::from_slice(&data).map_err(|e| {
1239 crate::errors::AuthError::internal(format!(
1240 "Failed to deserialize audit event: {}",
1241 e
1242 ))
1243 })?;
1244 Ok(Some(event))
1245 } else {
1246 Ok(None)
1247 }
1248 }
1249
1250 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1251 let events = self.query_events(query).await?;
1252 Ok(events.len() as u64)
1253 }
1254
1255 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1256 let all_keys = self.list_kv_keys("audit_event_").await?;
1257 let mut deleted_count = 0;
1258
1259 for key in all_keys {
1260 if let Some(data) = self.get_kv(&key).await?
1261 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1262 && event.timestamp < before
1263 {
1264 self.delete_kv(&key).await?;
1265 deleted_count += 1;
1266 }
1267 }
1268
1269 Ok(deleted_count)
1270 }
1271
1272 async fn get_statistics(
1273 &self,
1274 query: &crate::audit::StatsQuery,
1275 ) -> Result<crate::audit::AuditStatistics> {
1276 use std::collections::HashMap;
1277
1278 let audit_query = crate::audit::AuditQuery::builder()
1280 .time_range(query.time_range.start, query.time_range.end)
1281 .sort_order(crate::audit::SortOrder::TimestampAsc)
1282 .build();
1283 let events = self.query_events(&audit_query).await?;
1284 let total_events = events.len() as u64;
1285
1286 let mut event_type_counts: HashMap<String, u64> = HashMap::new();
1287 let mut risk_level_counts: HashMap<String, u64> = HashMap::new();
1288 let mut outcome_counts: HashMap<String, u64> = HashMap::new();
1289
1290 for event in &events {
1291 *event_type_counts
1292 .entry(format!("{:?}", event.event_type))
1293 .or_insert(0) += 1;
1294 *risk_level_counts
1295 .entry(format!("{:?}", event.risk_level))
1296 .or_insert(0) += 1;
1297 *outcome_counts
1298 .entry(format!("{:?}", event.outcome))
1299 .or_insert(0) += 1;
1300 }
1301
1302 Ok(crate::audit::AuditStatistics {
1303 total_events,
1304 event_type_counts,
1305 risk_level_counts,
1306 outcome_counts,
1307 time_series: Vec::new(),
1308 top_users: Vec::new(),
1309 top_ips: Vec::new(),
1310 })
1311 }
1312}
1313
1314impl MemoryStorage {
1315 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
1317 Ok(self.inner.list_kv_keys_by_prefix(_prefix))
1318 }
1319}
1320
1321#[async_trait]
1323impl crate::audit::AuditStorage for Arc<MemoryStorage> {
1324 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1325 self.as_ref().store_event(event).await
1326 }
1327
1328 async fn query_events(
1329 &self,
1330 query: &crate::audit::AuditQuery,
1331 ) -> Result<Vec<crate::audit::AuditEvent>> {
1332 self.as_ref().query_events(query).await
1333 }
1334
1335 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1336 self.as_ref().get_event(event_id).await
1337 }
1338
1339 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1340 self.as_ref().count_events(query).await
1341 }
1342
1343 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1344 self.as_ref().delete_old_events(before).await
1345 }
1346
1347 async fn get_statistics(
1348 &self,
1349 query: &crate::audit::StatsQuery,
1350 ) -> Result<crate::audit::AuditStatistics> {
1351 self.as_ref().get_statistics(query).await
1352 }
1353}
1354
1355#[cfg(test)]
1356mod tests {
1357 use super::*;
1358 use crate::tokens::AuthToken;
1359
1360 #[tokio::test]
1363 async fn test_memory_storage() {
1364 let storage = MemoryStorage::new();
1365
1366 let token = AuthToken::new("user123", "token123", Duration::from_secs(3600), "test");
1367
1368 storage.store_token(&token).await.unwrap();
1369
1370 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1371 assert_eq!(retrieved.user_id, "user123");
1372
1373 let retrieved = storage
1374 .get_token_by_access_token(&token.access_token)
1375 .await
1376 .unwrap()
1377 .unwrap();
1378 assert_eq!(retrieved.token_id, token.token_id);
1379
1380 let user_tokens = storage.list_user_tokens("user123").await.unwrap();
1381 assert_eq!(user_tokens.len(), 1);
1382
1383 storage.delete_token(&token.token_id).await.unwrap();
1384 let retrieved = storage.get_token(&token.token_id).await.unwrap();
1385 assert!(retrieved.is_none());
1386 }
1387
1388 #[tokio::test]
1389 async fn test_token_update() {
1390 let storage = MemoryStorage::new();
1391 let mut token = AuthToken::new("user1", "access_original", Duration::from_secs(3600), "pw");
1392 storage.store_token(&token).await.unwrap();
1393
1394 token.auth_method = "mfa".to_string();
1395 storage.update_token(&token).await.unwrap();
1396
1397 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1398 assert_eq!(retrieved.auth_method, "mfa");
1399 }
1400
1401 #[tokio::test]
1402 async fn test_token_get_nonexistent() {
1403 let storage = MemoryStorage::new();
1404 let result = storage.get_token("nonexistent").await.unwrap();
1405 assert!(result.is_none());
1406
1407 let result = storage
1408 .get_token_by_access_token("nonexistent")
1409 .await
1410 .unwrap();
1411 assert!(result.is_none());
1412 }
1413
1414 #[tokio::test]
1415 async fn test_list_user_tokens_multiple() {
1416 let storage = MemoryStorage::new();
1417 let t1 = AuthToken::new("user_a", "at1", Duration::from_secs(3600), "pw");
1418 let t2 = AuthToken::new("user_a", "at2", Duration::from_secs(3600), "pw");
1419 let t3 = AuthToken::new("user_b", "at3", Duration::from_secs(3600), "pw");
1420
1421 storage.store_token(&t1).await.unwrap();
1422 storage.store_token(&t2).await.unwrap();
1423 storage.store_token(&t3).await.unwrap();
1424
1425 let user_a_tokens = storage.list_user_tokens("user_a").await.unwrap();
1426 assert_eq!(user_a_tokens.len(), 2);
1427
1428 let user_b_tokens = storage.list_user_tokens("user_b").await.unwrap();
1429 assert_eq!(user_b_tokens.len(), 1);
1430
1431 let empty = storage.list_user_tokens("nobody").await.unwrap();
1432 assert!(empty.is_empty());
1433 }
1434
1435 #[tokio::test]
1436 async fn test_store_tokens_bulk() {
1437 let storage = MemoryStorage::new();
1438 let tokens = vec![
1439 AuthToken::new("u1", "a1", Duration::from_secs(3600), "pw"),
1440 AuthToken::new("u2", "a2", Duration::from_secs(3600), "pw"),
1441 AuthToken::new("u3", "a3", Duration::from_secs(3600), "pw"),
1442 ];
1443 let ids: Vec<String> = tokens.iter().map(|t| t.token_id.clone()).collect();
1444
1445 storage.store_tokens_bulk(&tokens).await.unwrap();
1446
1447 for id in &ids {
1448 assert!(storage.get_token(id).await.unwrap().is_some());
1449 }
1450
1451 storage.delete_tokens_bulk(&ids).await.unwrap();
1452
1453 for id in &ids {
1454 assert!(storage.get_token(id).await.unwrap().is_none());
1455 }
1456 }
1457
1458 #[tokio::test]
1461 async fn test_session_storage() {
1462 let storage = MemoryStorage::new();
1463
1464 let session = SessionData::new("session123", "user123", Duration::from_secs(3600))
1465 .with_metadata(
1466 Some("192.168.1.1".to_string()),
1467 Some("Test Agent".to_string()),
1468 );
1469
1470 storage
1471 .store_session(&session.session_id, &session)
1472 .await
1473 .unwrap();
1474
1475 let retrieved = storage
1476 .get_session(&session.session_id)
1477 .await
1478 .unwrap()
1479 .unwrap();
1480 assert_eq!(retrieved.user_id, "user123");
1481 assert_eq!(retrieved.ip_address, Some("192.168.1.1".to_string()));
1482
1483 storage.delete_session(&session.session_id).await.unwrap();
1484 let retrieved = storage.get_session(&session.session_id).await.unwrap();
1485 assert!(retrieved.is_none());
1486 }
1487
1488 #[tokio::test]
1489 async fn test_session_get_nonexistent() {
1490 let storage = MemoryStorage::new();
1491 let result = storage.get_session("no_such_session").await.unwrap();
1492 assert!(result.is_none());
1493 }
1494
1495 #[tokio::test]
1496 async fn test_list_user_sessions() {
1497 let storage = MemoryStorage::new();
1498
1499 let s1 = SessionData::new("s1", "alice", Duration::from_secs(3600));
1500 let s2 = SessionData::new("s2", "alice", Duration::from_secs(3600));
1501 let s3 = SessionData::new("s3", "bob", Duration::from_secs(3600));
1502
1503 storage.store_session("s1", &s1).await.unwrap();
1504 storage.store_session("s2", &s2).await.unwrap();
1505 storage.store_session("s3", &s3).await.unwrap();
1506
1507 let alice_sessions = storage.list_user_sessions("alice").await.unwrap();
1508 assert_eq!(alice_sessions.len(), 2);
1509
1510 let bob_sessions = storage.list_user_sessions("bob").await.unwrap();
1511 assert_eq!(bob_sessions.len(), 1);
1512 }
1513
1514 #[tokio::test]
1515 async fn test_count_active_sessions() {
1516 let storage = MemoryStorage::new();
1517
1518 let s1 = SessionData::new("cs1", "u1", Duration::from_secs(3600));
1519 let s2 = SessionData::new("cs2", "u2", Duration::from_secs(3600));
1520 storage.store_session("cs1", &s1).await.unwrap();
1521 storage.store_session("cs2", &s2).await.unwrap();
1522
1523 let count = storage.count_active_sessions().await.unwrap();
1524 assert!(count >= 2);
1525 }
1526
1527 #[tokio::test]
1528 async fn test_store_sessions_bulk() {
1529 let storage = MemoryStorage::new();
1530 let sessions = vec![
1531 (
1532 "bs1".to_string(),
1533 SessionData::new("bs1", "u1", Duration::from_secs(3600)),
1534 ),
1535 (
1536 "bs2".to_string(),
1537 SessionData::new("bs2", "u2", Duration::from_secs(3600)),
1538 ),
1539 ];
1540
1541 storage.store_sessions_bulk(&sessions).await.unwrap();
1542 assert!(storage.get_session("bs1").await.unwrap().is_some());
1543 assert!(storage.get_session("bs2").await.unwrap().is_some());
1544
1545 let ids = vec!["bs1".to_string(), "bs2".to_string()];
1546 storage.delete_sessions_bulk(&ids).await.unwrap();
1547 assert!(storage.get_session("bs1").await.unwrap().is_none());
1548 assert!(storage.get_session("bs2").await.unwrap().is_none());
1549 }
1550
1551 #[tokio::test]
1552 async fn test_session_custom_data() {
1553 let storage = MemoryStorage::new();
1554 let mut session = SessionData::new("sd1", "u1", Duration::from_secs(3600));
1555 session.set_data("theme", serde_json::json!("dark"));
1556 session.set_data("lang", serde_json::json!("en"));
1557
1558 storage.store_session("sd1", &session).await.unwrap();
1559
1560 let retrieved = storage.get_session("sd1").await.unwrap().unwrap();
1561 assert_eq!(
1562 retrieved.get_data("theme"),
1563 Some(&serde_json::json!("dark"))
1564 );
1565 assert_eq!(retrieved.get_data("lang"), Some(&serde_json::json!("en")));
1566 assert_eq!(retrieved.get_data("missing"), None);
1567 }
1568
1569 #[tokio::test]
1572 async fn test_kv_storage() {
1573 let storage = MemoryStorage::new();
1574
1575 let key = "test_key";
1576 let value = b"test_value";
1577
1578 storage
1579 .store_kv(key, value, Some(Duration::from_secs(3600)))
1580 .await
1581 .unwrap();
1582
1583 let retrieved = storage.get_kv(key).await.unwrap().unwrap();
1584 assert_eq!(retrieved, value);
1585
1586 storage.delete_kv(key).await.unwrap();
1587 let retrieved = storage.get_kv(key).await.unwrap();
1588 assert!(retrieved.is_none());
1589 }
1590
1591 #[tokio::test]
1592 async fn test_kv_no_ttl() {
1593 let storage = MemoryStorage::new();
1594 storage
1595 .store_kv("persistent", b"forever", None)
1596 .await
1597 .unwrap();
1598
1599 let retrieved = storage.get_kv("persistent").await.unwrap().unwrap();
1600 assert_eq!(retrieved, b"forever");
1601 }
1602
1603 #[tokio::test]
1604 async fn test_kv_overwrite() {
1605 let storage = MemoryStorage::new();
1606 storage
1607 .store_kv("k1", b"v1", Some(Duration::from_secs(3600)))
1608 .await
1609 .unwrap();
1610 storage
1611 .store_kv("k1", b"v2", Some(Duration::from_secs(3600)))
1612 .await
1613 .unwrap();
1614
1615 let retrieved = storage.get_kv("k1").await.unwrap().unwrap();
1616 assert_eq!(retrieved, b"v2");
1617 }
1618
1619 #[tokio::test]
1620 async fn test_kv_get_nonexistent() {
1621 let storage = MemoryStorage::new();
1622 let result = storage.get_kv("no_such_key").await.unwrap();
1623 assert!(result.is_none());
1624 }
1625
1626 #[tokio::test]
1627 async fn test_kv_list_keys_prefix() {
1628 let storage = MemoryStorage::new();
1629 storage
1630 .store_kv("user:1:name", b"alice", None)
1631 .await
1632 .unwrap();
1633 storage
1634 .store_kv("user:1:email", b"alice@x.com", None)
1635 .await
1636 .unwrap();
1637 storage.store_kv("user:2:name", b"bob", None).await.unwrap();
1638 storage
1639 .store_kv("session:abc", b"data", None)
1640 .await
1641 .unwrap();
1642
1643 let user1_keys = storage.list_kv_keys("user:1:").await.unwrap();
1644 assert_eq!(user1_keys.len(), 2);
1645
1646 let all_user_keys = storage.list_kv_keys("user:").await.unwrap();
1647 assert_eq!(all_user_keys.len(), 3);
1648
1649 let session_keys = storage.list_kv_keys("session:").await.unwrap();
1650 assert_eq!(session_keys.len(), 1);
1651
1652 let empty = storage.list_kv_keys("nonexistent:").await.unwrap();
1653 assert!(empty.is_empty());
1654 }
1655
1656 #[tokio::test]
1657 async fn test_kv_binary_data() {
1658 let storage = MemoryStorage::new();
1659 let binary = vec![0u8, 1, 2, 255, 254, 253, 0, 128];
1660 storage.store_kv("binary_key", &binary, None).await.unwrap();
1661
1662 let retrieved = storage.get_kv("binary_key").await.unwrap().unwrap();
1663 assert_eq!(retrieved, binary);
1664 }
1665
1666 #[tokio::test]
1669 async fn test_cleanup_expired() {
1670 let storage = MemoryStorage::new();
1671
1672 storage
1678 .store_kv("expire_me", b"val", Some(Duration::from_secs(0)))
1679 .await
1680 .unwrap();
1681 storage
1682 .store_kv("keep_me", b"val", Some(Duration::from_secs(3600)))
1683 .await
1684 .unwrap();
1685
1686 tokio::time::sleep(Duration::from_millis(10)).await;
1688
1689 storage.cleanup_expired().await.unwrap();
1690
1691 assert!(storage.get_kv("expire_me").await.unwrap().is_none());
1693 assert!(storage.get_kv("keep_me").await.unwrap().is_some());
1694 }
1695
1696 #[tokio::test]
1699 async fn test_session_is_expired() {
1700 let mut session = SessionData::new("exp1", "u1", Duration::from_secs(3600));
1701 assert!(!session.is_expired());
1702
1703 session.expires_at = chrono::Utc::now() - chrono::Duration::seconds(1);
1704 assert!(session.is_expired());
1705 }
1706
1707 #[tokio::test]
1708 async fn test_session_update_activity() {
1709 let mut session = SessionData::new("act1", "u1", Duration::from_secs(3600));
1710 let first_activity = session.last_activity;
1711 session.update_activity();
1713 assert!(session.last_activity >= first_activity);
1714 }
1715
1716 #[tokio::test]
1719 async fn test_token_store_twice_overwrites_primary() {
1720 let storage = MemoryStorage::new();
1721 let token = AuthToken::new("u1", "at1", Duration::from_secs(3600), "pw");
1722 let token_id = token.token_id.clone();
1723
1724 storage.store_token(&token).await.unwrap();
1725 storage.store_token(&token).await.unwrap();
1726
1727 let got = storage.get_token(&token_id).await.unwrap();
1729 assert!(got.is_some());
1730 }
1731
1732 #[tokio::test]
1735 async fn test_delete_nonexistent_token() {
1736 let storage = MemoryStorage::new();
1737 let result = storage.delete_token("nope").await;
1739 assert!(result.is_ok());
1740 }
1741
1742 #[tokio::test]
1743 async fn test_delete_nonexistent_session() {
1744 let storage = MemoryStorage::new();
1745 let result = storage.delete_session("nope").await;
1746 assert!(result.is_ok());
1747 }
1748
1749 #[tokio::test]
1750 async fn test_delete_nonexistent_kv() {
1751 let storage = MemoryStorage::new();
1752 let result = storage.delete_kv("nope").await;
1753 assert!(result.is_ok());
1754 }
1755}