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 (authorization-code and refresh-token redemption) \
163 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 delete_kv(&self, key: &str) -> Result<()>;
174
175 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
181 tracing::warn!(
182 "list_kv_keys called on a storage backend that does not override it — returning empty"
183 );
184 Ok(Vec::new())
185 }
186
187 async fn cleanup_expired(&self) -> Result<()>;
189}
190
191#[derive(Clone, Serialize, Deserialize)]
217pub struct SessionData {
218 pub session_id: String,
220
221 pub user_id: String,
223
224 pub created_at: chrono::DateTime<chrono::Utc>,
226
227 pub expires_at: chrono::DateTime<chrono::Utc>,
229
230 pub last_activity: chrono::DateTime<chrono::Utc>,
232
233 pub ip_address: Option<String>,
235
236 pub user_agent: Option<String>,
238
239 pub data: HashMap<String, serde_json::Value>,
241}
242
243impl std::fmt::Debug for SessionData {
244 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
245 let mut d = f.debug_struct("SessionData");
246 d.field(
247 "session_id",
248 &crate::utils::redact::redacted(&self.session_id),
249 );
250 d.field("user_id", &self.user_id);
251 d.field("created_at", &self.created_at);
252 d.field("expires_at", &self.expires_at);
253 d.field("last_activity", &self.last_activity);
254 d.field("ip_address", &self.ip_address);
255 d.field("user_agent", &self.user_agent);
256 d.field("data", &crate::utils::redact::redacted(&self.data));
257 d.finish()
258 }
259}
260
261#[derive(Debug, Clone)]
276pub struct MemoryStorage {
277 inner: crate::storage::dashmap_memory::DashMapMemoryStorage,
279 roles: Arc<RwLock<HashMap<String, crate::authorization::AbacRole>>>,
281 user_roles: Arc<RwLock<Vec<crate::authorization::UserRole>>>,
282}
283
284#[cfg(feature = "redis-storage")]
286#[derive(Debug, Clone)]
287pub struct RedisStorage {
288 client: redis::Client,
289 key_prefix: String,
290}
291
292impl Default for MemoryStorage {
293 fn default() -> Self {
294 Self::new()
295 }
296}
297
298impl MemoryStorage {
299 pub fn new() -> Self {
301 Self {
302 inner: crate::storage::dashmap_memory::DashMapMemoryStorage::new(),
303 roles: Arc::new(RwLock::new(HashMap::new())),
304 user_roles: Arc::new(RwLock::new(Vec::new())),
305 }
306 }
307}
308#[async_trait::async_trait]
310impl crate::authorization::AuthorizationStorage for MemoryStorage {
311 async fn store_role(&self, role: &crate::authorization::AbacRole) -> crate::errors::Result<()> {
312 let mut roles = self.roles.write().map_err(|_| {
313 crate::errors::AuthError::internal(
314 "Lock poisoned — a prior thread panicked while holding this lock",
315 )
316 })?;
317 roles.insert(role.id.clone(), role.clone());
318 Ok(())
319 }
320
321 async fn get_role(
322 &self,
323 role_id: &str,
324 ) -> crate::errors::Result<Option<crate::authorization::AbacRole>> {
325 let roles = self.roles.read().map_err(|_| {
326 crate::errors::AuthError::internal(
327 "Lock poisoned — a prior thread panicked while holding this lock",
328 )
329 })?;
330 Ok(roles.get(role_id).cloned())
331 }
332
333 async fn update_role(
334 &self,
335 role: &crate::authorization::AbacRole,
336 ) -> crate::errors::Result<()> {
337 let mut roles = self.roles.write().map_err(|_| {
338 crate::errors::AuthError::internal(
339 "Lock poisoned — a prior thread panicked while holding this lock",
340 )
341 })?;
342 roles.insert(role.id.clone(), role.clone());
343 Ok(())
344 }
345
346 async fn delete_role(&self, role_id: &str) -> crate::errors::Result<()> {
347 let mut roles = self.roles.write().map_err(|_| {
348 crate::errors::AuthError::internal(
349 "Lock poisoned — a prior thread panicked while holding this lock",
350 )
351 })?;
352 roles.remove(role_id);
353 Ok(())
354 }
355
356 async fn list_roles(&self) -> crate::errors::Result<Vec<crate::authorization::AbacRole>> {
357 let roles = self.roles.read().map_err(|_| {
358 crate::errors::AuthError::internal(
359 "Lock poisoned — a prior thread panicked while holding this lock",
360 )
361 })?;
362 Ok(roles.values().cloned().collect())
363 }
364
365 async fn assign_role(
366 &self,
367 user_role: &crate::authorization::UserRole,
368 ) -> crate::errors::Result<()> {
369 let mut user_roles = self.user_roles.write().map_err(|_| {
370 crate::errors::AuthError::internal(
371 "Lock poisoned — a prior thread panicked while holding this lock",
372 )
373 })?;
374 user_roles.push(user_role.clone());
375 Ok(())
376 }
377
378 async fn remove_role(&self, user_id: &str, role_id: &str) -> crate::errors::Result<()> {
379 let mut user_roles = self.user_roles.write().map_err(|_| {
380 crate::errors::AuthError::internal(
381 "Lock poisoned — a prior thread panicked while holding this lock",
382 )
383 })?;
384 user_roles.retain(|ur| ur.user_id != user_id || ur.role_id != role_id);
385 Ok(())
386 }
387
388 async fn get_user_roles(
389 &self,
390 user_id: &str,
391 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
392 let user_roles = self.user_roles.read().map_err(|_| {
393 crate::errors::AuthError::internal(
394 "Lock poisoned — a prior thread panicked while holding this lock",
395 )
396 })?;
397 Ok(user_roles
398 .iter()
399 .filter(|ur| ur.user_id == user_id)
400 .cloned()
401 .collect())
402 }
403
404 async fn get_role_users(
405 &self,
406 role_id: &str,
407 ) -> crate::errors::Result<Vec<crate::authorization::UserRole>> {
408 let user_roles = self.user_roles.read().map_err(|_| {
409 crate::errors::AuthError::internal(
410 "Lock poisoned — a prior thread panicked while holding this lock",
411 )
412 })?;
413 Ok(user_roles
414 .iter()
415 .filter(|ur| ur.role_id == role_id)
416 .cloned()
417 .collect())
418 }
419}
420
421#[async_trait]
422impl AuthStorage for MemoryStorage {
423 async fn store_token(&self, token: &AuthToken) -> Result<()> {
424 self.inner.store_token(token).await
426 }
427
428 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
429 self.inner.get_token(token_id).await
431 }
432
433 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
434 self.inner.get_token_by_access_token(access_token).await
436 }
437
438 async fn update_token(&self, token: &AuthToken) -> Result<()> {
439 self.inner.update_token(token).await
441 }
442
443 async fn delete_token(&self, token_id: &str) -> Result<()> {
444 self.inner.delete_token(token_id).await
446 }
447
448 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
449 self.inner.list_user_tokens(user_id).await
451 }
452
453 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
454 self.inner.store_session(session_id, data).await
456 }
457
458 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
459 self.inner.get_session(session_id).await
461 }
462
463 async fn delete_session(&self, session_id: &str) -> Result<()> {
464 self.inner.delete_session(session_id).await
466 }
467
468 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
469 self.inner.list_user_sessions(user_id).await
471 }
472
473 async fn count_active_sessions(&self) -> Result<u64> {
474 self.inner.count_active_sessions().await
476 }
477
478 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
479 self.inner.store_kv(key, value, ttl).await
481 }
482
483 async fn store_kv_if_absent(
484 &self,
485 key: &str,
486 value: &[u8],
487 ttl: Option<Duration>,
488 ) -> Result<bool> {
489 self.inner.store_kv_if_absent(key, value, ttl).await
490 }
491
492 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
493 self.inner.get_kv(key).await
495 }
496
497 async fn delete_kv(&self, key: &str) -> Result<()> {
498 self.inner.delete_kv(key).await
500 }
501
502 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
503 Ok(self.inner.list_kv_keys_by_prefix(prefix))
504 }
505
506 async fn cleanup_expired(&self) -> Result<()> {
507 self.inner.cleanup_expired().await
509 }
510}
511
512#[cfg(feature = "redis-storage")]
513impl RedisStorage {
514 pub fn new(redis_url: &str, key_prefix: impl Into<String>) -> Result<Self> {
516 let client = redis::Client::open(redis_url).map_err(|e| {
517 StorageError::connection_failed(format!("Redis connection failed: {e}"))
518 })?;
519
520 Ok(Self {
521 client,
522 key_prefix: key_prefix.into(),
523 })
524 }
525
526 async fn get_connection(&self) -> Result<redis::aio::MultiplexedConnection> {
528 self.client
529 .get_multiplexed_async_connection()
530 .await
531 .map_err(|e| {
532 StorageError::connection_failed(format!("Failed to get Redis connection: {e}"))
533 .into()
534 })
535 }
536
537 fn key(&self, suffix: &str) -> String {
539 format!("{}{}", self.key_prefix, suffix)
540 }
541
542 fn access_mapping_key(&self, access_token: &str) -> String {
546 self.key(&format!(
547 "access_token_h:{}",
548 crate::storage::key_names::digest("access_token", access_token)
549 ))
550 }
551
552 fn legacy_access_mapping_key(&self, access_token: &str) -> String {
554 self.key(&format!("access_token:{access_token}"))
555 }
556
557 fn session_key(&self, session_id: &str) -> String {
559 self.key(&format!(
560 "session_h:{}",
561 crate::storage::key_names::digest("session", session_id)
562 ))
563 }
564
565 fn legacy_session_key(&self, session_id: &str) -> String {
567 self.key(&format!("session:{session_id}"))
568 }
569
570 async fn session_keys(
576 &self,
577 conn: &mut redis::aio::MultiplexedConnection,
578 ) -> Result<Vec<String>> {
579 let mut keys = Vec::new();
580 for pattern in [self.key("session_h:*"), self.key("session:*")] {
581 let found: Vec<String> = redis::cmd("KEYS")
582 .arg(&pattern)
583 .query_async(&mut *conn)
584 .await
585 .map_err(|e| {
586 StorageError::operation_failed(format!("Failed to scan sessions: {e}"))
587 })?;
588 keys.extend(found);
589 }
590 Ok(keys)
591 }
592
593 async fn get_migrating(&self, new_key: &str, legacy_key: &str) -> Result<Option<String>> {
597 let mut conn = self.get_connection().await?;
598 let value: Option<String> = redis::cmd("GET")
601 .arg(new_key)
602 .query_async(&mut conn)
603 .await
604 .map_err(|e| StorageError::operation_failed(format!("Failed to read key: {e}")))?;
605 if value.is_some() {
606 let _ = redis::cmd("DEL")
609 .arg(legacy_key)
610 .query_async::<usize>(&mut conn)
611 .await;
612 return Ok(value);
613 }
614 const MIGRATE: &str = r#"
618 local l = redis.call('GET', KEYS[2])
619 if not l then return redis.call('GET', KEYS[1]) end
620 local v = redis.call('GET', KEYS[1])
621 if v then
622 redis.call('DEL', KEYS[2])
623 return v
624 end
625 local t = redis.call('PTTL', KEYS[2])
626 if t > 0 then
627 redis.call('SET', KEYS[1], l, 'PX', t)
628 elseif t == -1 then
629 redis.call('SET', KEYS[1], l)
630 else
631 return false
632 end
633 redis.call('DEL', KEYS[2])
634 return l
635 "#;
636 match redis::Script::new(MIGRATE)
637 .key(new_key)
638 .key(legacy_key)
639 .invoke_async::<Option<String>>(&mut conn)
640 .await
641 {
642 Ok(value) => Ok(value),
643 Err(script_err) => {
644 tracing::warn!(
648 error = %script_err,
649 "legacy-name migration script failed; serving the row unmigrated"
650 );
651 let legacy: Option<String> = redis::cmd("GET")
652 .arg(legacy_key)
653 .query_async(&mut conn)
654 .await
655 .map_err(|e| {
656 StorageError::operation_failed(format!("Failed to read key: {e}"))
657 })?;
658 Ok(legacy)
659 }
660 }
661 }
662
663 async fn del_legacy(&self, legacy_key: &str) -> Result<()> {
665 let mut conn = self.get_connection().await?;
666 let _: () = redis::cmd("DEL")
667 .arg(legacy_key)
668 .query_async(&mut conn)
669 .await
670 .map_err(|e| {
671 StorageError::operation_failed(format!("Failed to remove legacy key: {e}"))
672 })?;
673 Ok(())
674 }
675}
676
677#[cfg(feature = "redis-storage")]
678#[async_trait]
679impl AuthStorage for RedisStorage {
680 async fn store_token(&self, token: &AuthToken) -> Result<()> {
681 let mut conn = self.get_connection().await?;
682 let token_json = serde_json::to_string(token)
683 .map_err(|e| StorageError::serialization(format!("Token serialization failed: {e}")))?;
684
685 let token_key = self.key(&format!("token:{}", token.token_id));
686 let access_token_key = self.access_mapping_key(&token.access_token);
687 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
688
689 let ttl = token.time_until_expiry().as_secs().max(1);
691
692 let _: () = redis::cmd("SETEX")
694 .arg(&token_key)
695 .arg(ttl)
696 .arg(&token_json)
697 .query_async(&mut conn)
698 .await
699 .map_err(|e| StorageError::operation_failed(format!("Failed to store token: {e}")))?;
700
701 let _: () = redis::cmd("SETEX")
703 .arg(&access_token_key)
704 .arg(ttl)
705 .arg(&token.token_id)
706 .query_async(&mut conn)
707 .await
708 .map_err(|e| {
709 StorageError::operation_failed(format!("Failed to store access token mapping: {e}"))
710 })?;
711
712 self.del_legacy(&self.legacy_access_mapping_key(&token.access_token))
714 .await?;
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 token_id = self
751 .get_migrating(
752 &self.access_mapping_key(access_token),
753 &self.legacy_access_mapping_key(access_token),
754 )
755 .await?;
756
757 if let Some(token_id) = token_id {
758 self.get_token(&token_id).await
759 } else {
760 Ok(None)
761 }
762 }
763
764 async fn update_token(&self, token: &AuthToken) -> Result<()> {
765 self.store_token(token).await
767 }
768
769 async fn delete_token(&self, token_id: &str) -> Result<()> {
770 let mut conn = self.get_connection().await?;
771
772 if let Some(token) = self.get_token(token_id).await? {
774 let token_key = self.key(&format!("token:{token_id}"));
775 let access_token_key = self.access_mapping_key(&token.access_token);
776 let user_tokens_key = self.key(&format!("user_tokens:{}", token.user_id));
777 self.del_legacy(&self.legacy_access_mapping_key(&token.access_token))
778 .await?;
779
780 let _: () = redis::cmd("DEL")
782 .arg(&token_key)
783 .query_async(&mut conn)
784 .await
785 .map_err(|e| {
786 StorageError::operation_failed(format!("Failed to delete token: {e}"))
787 })?;
788
789 let _: () = redis::cmd("DEL")
791 .arg(&access_token_key)
792 .query_async(&mut conn)
793 .await
794 .map_err(|e| {
795 StorageError::operation_failed(format!(
796 "Failed to delete access token mapping: {e}"
797 ))
798 })?;
799
800 let _: () = redis::cmd("SREM")
802 .arg(&user_tokens_key)
803 .arg(token_id)
804 .query_async(&mut conn)
805 .await
806 .map_err(|e| {
807 StorageError::operation_failed(format!(
808 "Failed to remove token from user set: {e}"
809 ))
810 })?;
811 }
812
813 Ok(())
814 }
815
816 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
817 let mut conn = self.get_connection().await?;
818 let user_tokens_key = self.key(&format!("user_tokens:{user_id}"));
819
820 let token_ids: Vec<String> = redis::cmd("SMEMBERS")
821 .arg(&user_tokens_key)
822 .query_async(&mut conn)
823 .await
824 .map_err(|e| {
825 StorageError::operation_failed(format!("Failed to get user tokens: {e}"))
826 })?;
827
828 let mut tokens = Vec::new();
829 for token_id in token_ids {
830 if let Some(token) = self.get_token(&token_id).await? {
831 tokens.push(token);
832 }
833 }
834
835 Ok(tokens)
836 }
837
838 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
839 let mut conn = self.get_connection().await?;
840 let session_key = self.session_key(session_id);
841
842 let session_json = serde_json::to_string(data).map_err(|e| {
843 StorageError::serialization(format!("Session serialization failed: {e}"))
844 })?;
845
846 let ttl = (data.expires_at - chrono::Utc::now()).num_seconds().max(1);
847
848 let _: () = redis::cmd("SETEX")
849 .arg(&session_key)
850 .arg(ttl)
851 .arg(&session_json)
852 .query_async(&mut conn)
853 .await
854 .map_err(|e| StorageError::operation_failed(format!("Failed to store session: {e}")))?;
855
856 self.del_legacy(&self.legacy_session_key(session_id))
858 .await?;
859
860 Ok(())
861 }
862
863 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
864 let session_json = self
865 .get_migrating(
866 &self.session_key(session_id),
867 &self.legacy_session_key(session_id),
868 )
869 .await?;
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.session_key(session_id);
884
885 self.del_legacy(&self.legacy_session_key(session_id))
888 .await?;
889 let _: () = redis::cmd("DEL")
890 .arg(&session_key)
891 .query_async(&mut conn)
892 .await
893 .map_err(|e| {
894 StorageError::operation_failed(format!("Failed to delete session: {e}"))
895 })?;
896
897 Ok(())
898 }
899
900 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
901 let mut conn = self.get_connection().await?;
902 let keys = self.session_keys(&mut conn).await?;
903
904 let mut user_sessions = Vec::new();
905 let mut seen = std::collections::HashSet::new();
906
907 let legacy_prefix = self.legacy_session_key("");
909 for key in keys {
910 let session_json = match key.strip_prefix(&legacy_prefix) {
913 Some(session_id) => self
914 .get_migrating(&self.session_key(session_id), &key)
915 .await
916 .ok()
917 .flatten(),
918 None => redis::cmd("GET")
919 .arg(&key)
920 .query_async::<Option<String>>(&mut conn)
921 .await
922 .ok()
923 .flatten(),
924 };
925 if let Some(session_json) = session_json
926 && let Ok(session) = serde_json::from_str::<SessionData>(&session_json)
927 && session.user_id == user_id
928 && !session.is_expired()
929 && seen.insert(session.session_id.clone())
930 {
931 user_sessions.push(session);
932 }
933 }
934
935 Ok(user_sessions)
936 }
937
938 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
939 let mut conn = self.get_connection().await?;
940 let storage_key = self.key(&format!("kv:{key}"));
941
942 if let Some(ttl) = ttl {
943 let _: () = redis::cmd("SETEX")
944 .arg(&storage_key)
945 .arg(ttl.as_secs())
946 .arg(value)
947 .query_async(&mut conn)
948 .await
949 .map_err(|e| {
950 StorageError::operation_failed(format!("Failed to store KV with TTL: {e}"))
951 })?;
952 } else {
953 let _: () = redis::cmd("SET")
954 .arg(&storage_key)
955 .arg(value)
956 .query_async(&mut conn)
957 .await
958 .map_err(|e| StorageError::operation_failed(format!("Failed to store KV: {e}")))?;
959 }
960
961 Ok(())
962 }
963
964 async fn store_kv_if_absent(
965 &self,
966 key: &str,
967 value: &[u8],
968 ttl: Option<Duration>,
969 ) -> Result<bool> {
970 let mut conn = self.get_connection().await?;
971 let storage_key = self.key(&format!("kv:{key}"));
972 let mut cmd = redis::cmd("SET");
974 cmd.arg(&storage_key).arg(value).arg("NX");
975 if let Some(ttl) = ttl {
976 let millis = u64::try_from(ttl.as_millis()).unwrap_or(u64::MAX).max(1);
977 cmd.arg("PX").arg(millis);
978 }
979 let reply: Option<String> = cmd.query_async(&mut conn).await.map_err(|e| {
980 StorageError::operation_failed(format!("Failed to store KV if absent: {e}"))
981 })?;
982 Ok(reply.is_some())
983 }
984
985 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
986 let mut conn = self.get_connection().await?;
987 let storage_key = self.key(&format!("kv:{key}"));
988
989 let value: Option<Vec<u8>> = redis::cmd("GET")
990 .arg(&storage_key)
991 .query_async(&mut conn)
992 .await
993 .map_err(|e| StorageError::operation_failed(format!("Failed to get KV: {e}")))?;
994
995 Ok(value)
996 }
997
998 async fn delete_kv(&self, key: &str) -> Result<()> {
999 let mut conn = self.get_connection().await?;
1000 let storage_key = self.key(&format!("kv:{key}"));
1001
1002 let _: () = redis::cmd("DEL")
1003 .arg(&storage_key)
1004 .query_async(&mut conn)
1005 .await
1006 .map_err(|e| StorageError::operation_failed(format!("Failed to delete KV: {e}")))?;
1007
1008 Ok(())
1009 }
1010
1011 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
1012 let mut conn = self.get_connection().await?;
1013 let pattern = self.key(&format!("kv:{prefix}*"));
1014 let keys: Vec<String> = redis::cmd("KEYS")
1015 .arg(&pattern)
1016 .query_async(&mut conn)
1017 .await
1018 .map_err(|e| StorageError::operation_failed(format!("Failed to list KV keys: {e}")))?;
1019
1020 Ok(keys
1021 .into_iter()
1022 .filter_map(|key| key.strip_prefix(&self.key_prefix).map(str::to_string))
1023 .filter_map(|key| key.strip_prefix("kv:").map(str::to_string))
1024 .collect())
1025 }
1026
1027 async fn cleanup_expired(&self) -> Result<()> {
1028 Ok(())
1030 }
1031
1032 async fn count_active_sessions(&self) -> Result<u64> {
1033 let mut conn = self.get_connection().await?;
1034
1035 let keys = self.session_keys(&mut conn).await?;
1037 let keys = crate::storage::key_names::without_shadowed_legacy(
1039 keys,
1040 &self.legacy_session_key(""),
1041 &self.key("session_h:"),
1042 "session",
1043 );
1044
1045 let mut active_count = 0u64;
1047 for key in keys {
1048 let ttl: i64 = redis::cmd("TTL")
1049 .arg(&key)
1050 .query_async(&mut conn)
1051 .await
1052 .map_err(|e| StorageError::operation_failed(format!("Failed to check TTL: {e}")))?;
1053
1054 if ttl > 0 || ttl == -1 {
1058 active_count += 1;
1059 }
1060 }
1061
1062 Ok(active_count)
1063 }
1064}
1065
1066impl SessionData {
1067 pub fn new(
1080 session_id: impl Into<String>,
1081 user_id: impl Into<String>,
1082 expires_in: Duration,
1083 ) -> Self {
1084 let now = chrono::Utc::now();
1085
1086 Self {
1087 session_id: session_id.into(),
1088 user_id: user_id.into(),
1089 created_at: now,
1090 expires_at: now
1091 + chrono::Duration::from_std(expires_in).unwrap_or(chrono::Duration::hours(1)),
1092 last_activity: now,
1093 ip_address: None,
1094 user_agent: None,
1095 data: HashMap::new(),
1096 }
1097 }
1098
1099 pub fn is_expired(&self) -> bool {
1101 chrono::Utc::now() > self.expires_at
1102 }
1103
1104 pub fn time_until_expiry(&self) -> std::time::Duration {
1109 let remaining = self.expires_at - chrono::Utc::now();
1110 remaining.to_std().unwrap_or(std::time::Duration::ZERO)
1111 }
1112
1113 pub fn is_active(&self) -> bool {
1115 !self.is_expired()
1116 }
1117
1118 pub fn update_activity(&mut self) {
1120 self.last_activity = chrono::Utc::now();
1121 }
1122
1123 pub fn with_metadata(mut self, ip_address: Option<String>, user_agent: Option<String>) -> Self {
1125 self.ip_address = ip_address;
1126 self.user_agent = user_agent;
1127 self
1128 }
1129
1130 pub fn ip_address(mut self, ip: impl Into<String>) -> Self {
1132 self.ip_address = Some(ip.into());
1133 self
1134 }
1135
1136 pub fn user_agent(mut self, ua: impl Into<String>) -> Self {
1138 self.user_agent = Some(ua.into());
1139 self
1140 }
1141
1142 pub fn with_data(mut self, key: impl Into<String>, value: serde_json::Value) -> Self {
1144 self.data.insert(key.into(), value);
1145 self
1146 }
1147
1148 pub fn set_data(&mut self, key: impl Into<String>, value: serde_json::Value) {
1150 self.data.insert(key.into(), value);
1151 }
1152
1153 pub fn get_data(&self, key: &str) -> Option<&serde_json::Value> {
1155 self.data.get(key)
1156 }
1157}
1158
1159#[async_trait]
1161impl crate::audit::AuditStorage for MemoryStorage {
1162 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1163 let json_data = serde_json::to_vec(event).map_err(|e| {
1165 crate::errors::AuthError::internal(format!("Failed to serialize audit event: {}", e))
1166 })?;
1167
1168 let key = format!("audit_event_{}", event.id);
1169 self.store_kv(&key, &json_data, None).await
1170 }
1171
1172 async fn query_events(
1173 &self,
1174 query: &crate::audit::AuditQuery,
1175 ) -> Result<Vec<crate::audit::AuditEvent>> {
1176 let all_keys = self.list_kv_keys("audit_event_").await?;
1178 let mut events = Vec::new();
1179
1180 for key in all_keys {
1181 if let Some(data) = self.get_kv(&key).await?
1182 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1183 {
1184 let mut include = true;
1186
1187 if let Some(ref time_range) = query.time_range
1188 && (event.timestamp < time_range.start || event.timestamp > time_range.end)
1189 {
1190 include = false;
1191 }
1192
1193 if let Some(ref event_types) = query.event_types
1194 && !event_types.contains(&event.event_type)
1195 {
1196 include = false;
1197 }
1198
1199 if let Some(ref user_id) = query.user_id
1200 && event.user_id.as_ref() != Some(user_id)
1201 {
1202 include = false;
1203 }
1204
1205 if include {
1206 events.push(event);
1207 }
1208 }
1209 }
1210
1211 events.sort_by(|a, b| match query.sort_order {
1213 crate::audit::SortOrder::TimestampAsc => a.timestamp.cmp(&b.timestamp),
1214 crate::audit::SortOrder::TimestampDesc => b.timestamp.cmp(&a.timestamp),
1215 crate::audit::SortOrder::RiskLevelDesc => b.risk_level.cmp(&a.risk_level),
1216 });
1217
1218 if let Some(limit) = query.limit {
1219 events.truncate(limit as usize);
1220 }
1221 Ok(events)
1222 }
1223
1224 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1225 let key = format!("audit_event_{}", event_id);
1226 if let Some(data) = self.get_kv(&key).await? {
1227 let event = serde_json::from_slice(&data).map_err(|e| {
1228 crate::errors::AuthError::internal(format!(
1229 "Failed to deserialize audit event: {}",
1230 e
1231 ))
1232 })?;
1233 Ok(Some(event))
1234 } else {
1235 Ok(None)
1236 }
1237 }
1238
1239 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1240 let events = self.query_events(query).await?;
1241 Ok(events.len() as u64)
1242 }
1243
1244 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1245 let all_keys = self.list_kv_keys("audit_event_").await?;
1246 let mut deleted_count = 0;
1247
1248 for key in all_keys {
1249 if let Some(data) = self.get_kv(&key).await?
1250 && let Ok(event) = serde_json::from_slice::<crate::audit::AuditEvent>(&data)
1251 && event.timestamp < before
1252 {
1253 self.delete_kv(&key).await?;
1254 deleted_count += 1;
1255 }
1256 }
1257
1258 Ok(deleted_count)
1259 }
1260
1261 async fn get_statistics(
1262 &self,
1263 query: &crate::audit::StatsQuery,
1264 ) -> Result<crate::audit::AuditStatistics> {
1265 use std::collections::HashMap;
1266
1267 let audit_query = crate::audit::AuditQuery::builder()
1269 .time_range(query.time_range.start, query.time_range.end)
1270 .sort_order(crate::audit::SortOrder::TimestampAsc)
1271 .build();
1272 let events = self.query_events(&audit_query).await?;
1273 let total_events = events.len() as u64;
1274
1275 let mut event_type_counts: HashMap<String, u64> = HashMap::new();
1276 let mut risk_level_counts: HashMap<String, u64> = HashMap::new();
1277 let mut outcome_counts: HashMap<String, u64> = HashMap::new();
1278
1279 for event in &events {
1280 *event_type_counts
1281 .entry(format!("{:?}", event.event_type))
1282 .or_insert(0) += 1;
1283 *risk_level_counts
1284 .entry(format!("{:?}", event.risk_level))
1285 .or_insert(0) += 1;
1286 *outcome_counts
1287 .entry(format!("{:?}", event.outcome))
1288 .or_insert(0) += 1;
1289 }
1290
1291 Ok(crate::audit::AuditStatistics {
1292 total_events,
1293 event_type_counts,
1294 risk_level_counts,
1295 outcome_counts,
1296 time_series: Vec::new(),
1297 top_users: Vec::new(),
1298 top_ips: Vec::new(),
1299 })
1300 }
1301}
1302
1303impl MemoryStorage {
1304 async fn list_kv_keys(&self, _prefix: &str) -> Result<Vec<String>> {
1306 Ok(self.inner.list_kv_keys_by_prefix(_prefix))
1307 }
1308}
1309
1310#[async_trait]
1312impl crate::audit::AuditStorage for Arc<MemoryStorage> {
1313 async fn store_event(&self, event: &crate::audit::AuditEvent) -> Result<()> {
1314 self.as_ref().store_event(event).await
1315 }
1316
1317 async fn query_events(
1318 &self,
1319 query: &crate::audit::AuditQuery,
1320 ) -> Result<Vec<crate::audit::AuditEvent>> {
1321 self.as_ref().query_events(query).await
1322 }
1323
1324 async fn get_event(&self, event_id: &str) -> Result<Option<crate::audit::AuditEvent>> {
1325 self.as_ref().get_event(event_id).await
1326 }
1327
1328 async fn count_events(&self, query: &crate::audit::AuditQuery) -> Result<u64> {
1329 self.as_ref().count_events(query).await
1330 }
1331
1332 async fn delete_old_events(&self, before: std::time::SystemTime) -> Result<u64> {
1333 self.as_ref().delete_old_events(before).await
1334 }
1335
1336 async fn get_statistics(
1337 &self,
1338 query: &crate::audit::StatsQuery,
1339 ) -> Result<crate::audit::AuditStatistics> {
1340 self.as_ref().get_statistics(query).await
1341 }
1342}
1343
1344#[cfg(test)]
1345mod tests {
1346 use super::*;
1347 use crate::tokens::AuthToken;
1348
1349 #[tokio::test]
1352 async fn test_memory_storage() {
1353 let storage = MemoryStorage::new();
1354
1355 let token = AuthToken::new("user123", "token123", Duration::from_secs(3600), "test");
1356
1357 storage.store_token(&token).await.unwrap();
1358
1359 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1360 assert_eq!(retrieved.user_id, "user123");
1361
1362 let retrieved = storage
1363 .get_token_by_access_token(&token.access_token)
1364 .await
1365 .unwrap()
1366 .unwrap();
1367 assert_eq!(retrieved.token_id, token.token_id);
1368
1369 let user_tokens = storage.list_user_tokens("user123").await.unwrap();
1370 assert_eq!(user_tokens.len(), 1);
1371
1372 storage.delete_token(&token.token_id).await.unwrap();
1373 let retrieved = storage.get_token(&token.token_id).await.unwrap();
1374 assert!(retrieved.is_none());
1375 }
1376
1377 #[tokio::test]
1378 async fn test_token_update() {
1379 let storage = MemoryStorage::new();
1380 let mut token = AuthToken::new("user1", "access_original", Duration::from_secs(3600), "pw");
1381 storage.store_token(&token).await.unwrap();
1382
1383 token.auth_method = "mfa".to_string();
1384 storage.update_token(&token).await.unwrap();
1385
1386 let retrieved = storage.get_token(&token.token_id).await.unwrap().unwrap();
1387 assert_eq!(retrieved.auth_method, "mfa");
1388 }
1389
1390 #[tokio::test]
1391 async fn test_token_get_nonexistent() {
1392 let storage = MemoryStorage::new();
1393 let result = storage.get_token("nonexistent").await.unwrap();
1394 assert!(result.is_none());
1395
1396 let result = storage
1397 .get_token_by_access_token("nonexistent")
1398 .await
1399 .unwrap();
1400 assert!(result.is_none());
1401 }
1402
1403 #[tokio::test]
1404 async fn test_list_user_tokens_multiple() {
1405 let storage = MemoryStorage::new();
1406 let t1 = AuthToken::new("user_a", "at1", Duration::from_secs(3600), "pw");
1407 let t2 = AuthToken::new("user_a", "at2", Duration::from_secs(3600), "pw");
1408 let t3 = AuthToken::new("user_b", "at3", Duration::from_secs(3600), "pw");
1409
1410 storage.store_token(&t1).await.unwrap();
1411 storage.store_token(&t2).await.unwrap();
1412 storage.store_token(&t3).await.unwrap();
1413
1414 let user_a_tokens = storage.list_user_tokens("user_a").await.unwrap();
1415 assert_eq!(user_a_tokens.len(), 2);
1416
1417 let user_b_tokens = storage.list_user_tokens("user_b").await.unwrap();
1418 assert_eq!(user_b_tokens.len(), 1);
1419
1420 let empty = storage.list_user_tokens("nobody").await.unwrap();
1421 assert!(empty.is_empty());
1422 }
1423
1424 #[tokio::test]
1425 async fn test_store_tokens_bulk() {
1426 let storage = MemoryStorage::new();
1427 let tokens = vec![
1428 AuthToken::new("u1", "a1", Duration::from_secs(3600), "pw"),
1429 AuthToken::new("u2", "a2", Duration::from_secs(3600), "pw"),
1430 AuthToken::new("u3", "a3", Duration::from_secs(3600), "pw"),
1431 ];
1432 let ids: Vec<String> = tokens.iter().map(|t| t.token_id.clone()).collect();
1433
1434 storage.store_tokens_bulk(&tokens).await.unwrap();
1435
1436 for id in &ids {
1437 assert!(storage.get_token(id).await.unwrap().is_some());
1438 }
1439
1440 storage.delete_tokens_bulk(&ids).await.unwrap();
1441
1442 for id in &ids {
1443 assert!(storage.get_token(id).await.unwrap().is_none());
1444 }
1445 }
1446
1447 #[tokio::test]
1450 async fn test_session_storage() {
1451 let storage = MemoryStorage::new();
1452
1453 let session = SessionData::new("session123", "user123", Duration::from_secs(3600))
1454 .with_metadata(
1455 Some("192.168.1.1".to_string()),
1456 Some("Test Agent".to_string()),
1457 );
1458
1459 storage
1460 .store_session(&session.session_id, &session)
1461 .await
1462 .unwrap();
1463
1464 let retrieved = storage
1465 .get_session(&session.session_id)
1466 .await
1467 .unwrap()
1468 .unwrap();
1469 assert_eq!(retrieved.user_id, "user123");
1470 assert_eq!(retrieved.ip_address, Some("192.168.1.1".to_string()));
1471
1472 storage.delete_session(&session.session_id).await.unwrap();
1473 let retrieved = storage.get_session(&session.session_id).await.unwrap();
1474 assert!(retrieved.is_none());
1475 }
1476
1477 #[tokio::test]
1478 async fn test_session_get_nonexistent() {
1479 let storage = MemoryStorage::new();
1480 let result = storage.get_session("no_such_session").await.unwrap();
1481 assert!(result.is_none());
1482 }
1483
1484 #[tokio::test]
1485 async fn test_list_user_sessions() {
1486 let storage = MemoryStorage::new();
1487
1488 let s1 = SessionData::new("s1", "alice", Duration::from_secs(3600));
1489 let s2 = SessionData::new("s2", "alice", Duration::from_secs(3600));
1490 let s3 = SessionData::new("s3", "bob", Duration::from_secs(3600));
1491
1492 storage.store_session("s1", &s1).await.unwrap();
1493 storage.store_session("s2", &s2).await.unwrap();
1494 storage.store_session("s3", &s3).await.unwrap();
1495
1496 let alice_sessions = storage.list_user_sessions("alice").await.unwrap();
1497 assert_eq!(alice_sessions.len(), 2);
1498
1499 let bob_sessions = storage.list_user_sessions("bob").await.unwrap();
1500 assert_eq!(bob_sessions.len(), 1);
1501 }
1502
1503 #[tokio::test]
1504 async fn test_count_active_sessions() {
1505 let storage = MemoryStorage::new();
1506
1507 let s1 = SessionData::new("cs1", "u1", Duration::from_secs(3600));
1508 let s2 = SessionData::new("cs2", "u2", Duration::from_secs(3600));
1509 storage.store_session("cs1", &s1).await.unwrap();
1510 storage.store_session("cs2", &s2).await.unwrap();
1511
1512 let count = storage.count_active_sessions().await.unwrap();
1513 assert!(count >= 2);
1514 }
1515
1516 #[tokio::test]
1517 async fn test_store_sessions_bulk() {
1518 let storage = MemoryStorage::new();
1519 let sessions = vec![
1520 (
1521 "bs1".to_string(),
1522 SessionData::new("bs1", "u1", Duration::from_secs(3600)),
1523 ),
1524 (
1525 "bs2".to_string(),
1526 SessionData::new("bs2", "u2", Duration::from_secs(3600)),
1527 ),
1528 ];
1529
1530 storage.store_sessions_bulk(&sessions).await.unwrap();
1531 assert!(storage.get_session("bs1").await.unwrap().is_some());
1532 assert!(storage.get_session("bs2").await.unwrap().is_some());
1533
1534 let ids = vec!["bs1".to_string(), "bs2".to_string()];
1535 storage.delete_sessions_bulk(&ids).await.unwrap();
1536 assert!(storage.get_session("bs1").await.unwrap().is_none());
1537 assert!(storage.get_session("bs2").await.unwrap().is_none());
1538 }
1539
1540 #[tokio::test]
1541 async fn test_session_custom_data() {
1542 let storage = MemoryStorage::new();
1543 let mut session = SessionData::new("sd1", "u1", Duration::from_secs(3600));
1544 session.set_data("theme", serde_json::json!("dark"));
1545 session.set_data("lang", serde_json::json!("en"));
1546
1547 storage.store_session("sd1", &session).await.unwrap();
1548
1549 let retrieved = storage.get_session("sd1").await.unwrap().unwrap();
1550 assert_eq!(
1551 retrieved.get_data("theme"),
1552 Some(&serde_json::json!("dark"))
1553 );
1554 assert_eq!(retrieved.get_data("lang"), Some(&serde_json::json!("en")));
1555 assert_eq!(retrieved.get_data("missing"), None);
1556 }
1557
1558 #[tokio::test]
1561 async fn test_kv_storage() {
1562 let storage = MemoryStorage::new();
1563
1564 let key = "test_key";
1565 let value = b"test_value";
1566
1567 storage
1568 .store_kv(key, value, Some(Duration::from_secs(3600)))
1569 .await
1570 .unwrap();
1571
1572 let retrieved = storage.get_kv(key).await.unwrap().unwrap();
1573 assert_eq!(retrieved, value);
1574
1575 storage.delete_kv(key).await.unwrap();
1576 let retrieved = storage.get_kv(key).await.unwrap();
1577 assert!(retrieved.is_none());
1578 }
1579
1580 #[tokio::test]
1581 async fn test_kv_no_ttl() {
1582 let storage = MemoryStorage::new();
1583 storage
1584 .store_kv("persistent", b"forever", None)
1585 .await
1586 .unwrap();
1587
1588 let retrieved = storage.get_kv("persistent").await.unwrap().unwrap();
1589 assert_eq!(retrieved, b"forever");
1590 }
1591
1592 #[tokio::test]
1593 async fn test_kv_overwrite() {
1594 let storage = MemoryStorage::new();
1595 storage
1596 .store_kv("k1", b"v1", Some(Duration::from_secs(3600)))
1597 .await
1598 .unwrap();
1599 storage
1600 .store_kv("k1", b"v2", Some(Duration::from_secs(3600)))
1601 .await
1602 .unwrap();
1603
1604 let retrieved = storage.get_kv("k1").await.unwrap().unwrap();
1605 assert_eq!(retrieved, b"v2");
1606 }
1607
1608 #[tokio::test]
1609 async fn test_kv_get_nonexistent() {
1610 let storage = MemoryStorage::new();
1611 let result = storage.get_kv("no_such_key").await.unwrap();
1612 assert!(result.is_none());
1613 }
1614
1615 #[tokio::test]
1616 async fn test_kv_list_keys_prefix() {
1617 let storage = MemoryStorage::new();
1618 storage
1619 .store_kv("user:1:name", b"alice", None)
1620 .await
1621 .unwrap();
1622 storage
1623 .store_kv("user:1:email", b"alice@x.com", None)
1624 .await
1625 .unwrap();
1626 storage.store_kv("user:2:name", b"bob", None).await.unwrap();
1627 storage
1628 .store_kv("session:abc", b"data", None)
1629 .await
1630 .unwrap();
1631
1632 let user1_keys = storage.list_kv_keys("user:1:").await.unwrap();
1633 assert_eq!(user1_keys.len(), 2);
1634
1635 let all_user_keys = storage.list_kv_keys("user:").await.unwrap();
1636 assert_eq!(all_user_keys.len(), 3);
1637
1638 let session_keys = storage.list_kv_keys("session:").await.unwrap();
1639 assert_eq!(session_keys.len(), 1);
1640
1641 let empty = storage.list_kv_keys("nonexistent:").await.unwrap();
1642 assert!(empty.is_empty());
1643 }
1644
1645 #[tokio::test]
1646 async fn test_kv_binary_data() {
1647 let storage = MemoryStorage::new();
1648 let binary = vec![0u8, 1, 2, 255, 254, 253, 0, 128];
1649 storage.store_kv("binary_key", &binary, None).await.unwrap();
1650
1651 let retrieved = storage.get_kv("binary_key").await.unwrap().unwrap();
1652 assert_eq!(retrieved, binary);
1653 }
1654
1655 #[tokio::test]
1658 async fn test_cleanup_expired() {
1659 let storage = MemoryStorage::new();
1660
1661 storage
1667 .store_kv("expire_me", b"val", Some(Duration::from_secs(0)))
1668 .await
1669 .unwrap();
1670 storage
1671 .store_kv("keep_me", b"val", Some(Duration::from_secs(3600)))
1672 .await
1673 .unwrap();
1674
1675 tokio::time::sleep(Duration::from_millis(10)).await;
1677
1678 storage.cleanup_expired().await.unwrap();
1679
1680 assert!(storage.get_kv("expire_me").await.unwrap().is_none());
1682 assert!(storage.get_kv("keep_me").await.unwrap().is_some());
1683 }
1684
1685 #[tokio::test]
1688 async fn test_session_is_expired() {
1689 let mut session = SessionData::new("exp1", "u1", Duration::from_secs(3600));
1690 assert!(!session.is_expired());
1691
1692 session.expires_at = chrono::Utc::now() - chrono::Duration::seconds(1);
1693 assert!(session.is_expired());
1694 }
1695
1696 #[tokio::test]
1697 async fn test_session_update_activity() {
1698 let mut session = SessionData::new("act1", "u1", Duration::from_secs(3600));
1699 let first_activity = session.last_activity;
1700 session.update_activity();
1702 assert!(session.last_activity >= first_activity);
1703 }
1704
1705 #[tokio::test]
1708 async fn test_token_store_twice_overwrites_primary() {
1709 let storage = MemoryStorage::new();
1710 let token = AuthToken::new("u1", "at1", Duration::from_secs(3600), "pw");
1711 let token_id = token.token_id.clone();
1712
1713 storage.store_token(&token).await.unwrap();
1714 storage.store_token(&token).await.unwrap();
1715
1716 let got = storage.get_token(&token_id).await.unwrap();
1718 assert!(got.is_some());
1719 }
1720
1721 #[tokio::test]
1724 async fn test_delete_nonexistent_token() {
1725 let storage = MemoryStorage::new();
1726 let result = storage.delete_token("nope").await;
1728 assert!(result.is_ok());
1729 }
1730
1731 #[tokio::test]
1732 async fn test_delete_nonexistent_session() {
1733 let storage = MemoryStorage::new();
1734 let result = storage.delete_session("nope").await;
1735 assert!(result.is_ok());
1736 }
1737
1738 #[tokio::test]
1739 async fn test_delete_nonexistent_kv() {
1740 let storage = MemoryStorage::new();
1741 let result = storage.delete_kv("nope").await;
1742 assert!(result.is_ok());
1743 }
1744}