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