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