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