1use crate::errors::{AuthError, Result};
4use crate::storage::AuthStorage;
5use std::collections::HashMap;
6use std::sync::Arc;
7use tracing::{debug, info, warn};
8
9pub type UserInfo = crate::auth::UserInfo;
11
12pub struct CredentialCheckResult {
21 pub user_id: String,
23 pub mfa_enabled: bool,
25}
26
27pub struct UserManager {
36 storage: Arc<dyn AuthStorage>,
37}
38
39impl UserManager {
40 pub fn new(storage: Arc<dyn AuthStorage>) -> Self {
47 Self { storage }
48 }
49
50 fn api_key_storage_key(api_key: &str) -> String {
53 format!(
54 "api_key_h:{}",
55 crate::storage::key_names::digest("api_key", api_key)
56 )
57 }
58
59 fn legacy_api_key_storage_key(api_key: &str) -> String {
61 format!("api_key:{api_key}")
62 }
63
64 fn revoked_marker_key(api_key: &str) -> String {
69 format!(
70 "api_key_revoked:{}",
71 crate::storage::key_names::digest("api_key", api_key)
72 )
73 }
74
75 async fn get_api_key_row(&self, api_key: &str, storage_key: &str) -> Result<Option<Vec<u8>>> {
86 if let Some(row) = self.storage.get_kv(storage_key).await? {
87 return Ok(Some(row));
88 }
89 let legacy_key = Self::legacy_api_key_storage_key(api_key);
90 let Some(row) = self.storage.get_kv(&legacy_key).await? else {
91 return self.storage.get_kv(storage_key).await;
94 };
95
96 let ttl = match serde_json::from_slice::<serde_json::Value>(&row)
97 .ok()
98 .and_then(|v| v["expires_at"].as_str().map(str::to_owned))
99 .and_then(|s| s.parse::<chrono::DateTime<chrono::Utc>>().ok())
100 .map(|at| at - chrono::Utc::now())
101 {
102 Some(left) if left <= chrono::Duration::zero() => return Ok(Some(row)),
104 Some(left) => left.to_std().ok().map(|d| {
106 std::time::Duration::from_secs(d.as_secs() + u64::from(d.subsec_nanos() > 0))
107 }),
108 None => None,
109 };
110
111 self.storage.store_kv(storage_key, &row, ttl).await?;
112 if self
113 .storage
114 .get_kv(&Self::revoked_marker_key(api_key))
115 .await?
116 .is_some()
117 {
118 self.storage.delete_kv(storage_key).await?;
120 return Ok(None);
121 }
122 self.storage.delete_kv(&legacy_key).await?;
123 Ok(Some(row))
124 }
125
126 pub async fn create_api_key(
133 &self,
134 user_id: &str,
135 expires_in: Option<std::time::Duration>,
136 ) -> Result<String> {
137 debug!("Creating API key for user '{}'", user_id);
138
139 let api_key = format!("ak_{}", crate::utils::crypto::generate_token(32));
141
142 let key_data = serde_json::json!({
144 "user_id": user_id,
145 "created_at": chrono::Utc::now(),
146 "expires_at": expires_in.map(|d| chrono::Utc::now() + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::days(365 * 10)))
147 });
148
149 let storage_key = Self::api_key_storage_key(&api_key);
152 self.storage
153 .store_kv(&storage_key, key_data.to_string().as_bytes(), expires_in)
154 .await?;
155
156 info!("API key created for user '{}'", user_id);
157 Ok(api_key)
158 }
159
160 pub async fn validate_api_key(&self, api_key: &str) -> Result<UserInfo> {
168 debug!("Validating API key");
169
170 let storage_key = Self::api_key_storage_key(api_key);
171 if let Some(key_data) = self.get_api_key_row(api_key, &storage_key).await? {
172 let key_info: serde_json::Value = serde_json::from_slice(&key_data)?;
173
174 if let Some(user_id) = key_info["user_id"].as_str() {
175 crate::account_state::ensure_account_active(&*self.storage, user_id).await?;
178 let created_ms = key_info["created_at"]
179 .as_str()
180 .and_then(|s| s.parse::<chrono::DateTime<chrono::Utc>>().ok())
181 .map(|t| t.timestamp_millis());
182 crate::account_state::ensure_issued_after_revocation(
185 &*self.storage,
186 user_id,
187 created_ms.unwrap_or(0),
188 )
189 .await?;
190 if let Some(expires_at_str) = key_info["expires_at"].as_str() {
192 let expires_at: chrono::DateTime<chrono::Utc> = expires_at_str
193 .parse()
194 .map_err(|_| AuthError::token("Invalid API key expiration"))?;
195
196 if chrono::Utc::now() > expires_at {
197 return Err(AuthError::token("API key expired"));
198 }
199 }
200
201 Ok(UserInfo {
203 id: user_id.to_string(),
204 username: format!("api_user_{}", user_id),
205 email: None,
206 name: None,
207 roles: vec!["api_user".to_string()].into(),
208 active: true,
209 email_verified: false,
210 attributes: crate::types::UserAttributes::empty(),
211 })
212 } else {
213 Err(AuthError::token("Invalid API key format"))
214 }
215 } else {
216 Err(AuthError::token("Invalid API key"))
217 }
218 }
219
220 pub async fn revoke_api_key(&self, api_key: &str) -> Result<()> {
227 debug!("Revoking API key");
228
229 let storage_key = Self::api_key_storage_key(api_key);
230 let legacy_key = Self::legacy_api_key_storage_key(api_key);
231 let found_legacy = self.storage.get_kv(&legacy_key).await?.is_some();
235 let found_new = self.storage.get_kv(&storage_key).await?.is_some();
236 if found_new || found_legacy {
237 self.storage
240 .store_kv(
241 &Self::revoked_marker_key(api_key),
242 b"1",
243 Some(std::time::Duration::from_secs(300)),
244 )
245 .await?;
246 self.storage.delete_kv(&legacy_key).await?;
249 self.storage.delete_kv(&storage_key).await?;
250 info!("API key revoked");
251 Ok(())
252 } else {
253 Err(AuthError::token("API key not found"))
254 }
255 }
256
257 pub async fn validate_username(&self, username: &str) -> Result<bool> {
265 debug!("Validating username format: '{}'", username);
266
267 let is_valid = username.len() >= 3
268 && username.len() <= 32
269 && username
270 .chars()
271 .all(|c| c.is_alphanumeric() || c == '_' || c == '-');
272
273 Ok(is_valid)
274 }
275
276 pub async fn validate_display_name(&self, display_name: &str) -> Result<bool> {
283 debug!("Validating display name format");
284
285 let is_valid = !display_name.is_empty()
286 && display_name.len() <= 100
287 && !display_name.trim().is_empty();
288
289 Ok(is_valid)
290 }
291
292 pub async fn validate_password_strength(&self, password: &str) -> Result<bool> {
302 debug!("Validating password strength");
303 let strength = crate::utils::password::check_password_strength(password);
304 let is_valid = crate::utils::password::meets_production_strength(strength.level);
305 if !is_valid {
306 warn!(
307 "Password validation failed - Actual: {:?}, Feedback: {}",
308 strength.level,
309 strength.feedback.join(", ")
310 );
311 }
312 Ok(is_valid)
313 }
314
315 pub async fn validate_user_input(&self, input: &str) -> Result<bool> {
327 debug!("Validating user input");
328
329 if input.is_empty() || input.len() > 1000 {
330 return Ok(false);
331 }
332
333 if !input.chars().all(|c| {
335 if c.is_control() {
336 matches!(c, ' ' | '\t' | '\n' | '\r')
337 } else {
338 !matches!(c, '<' | '>')
339 }
340 }) {
341 return Ok(false);
342 }
343
344 let lower = input.to_ascii_lowercase();
345 if lower.contains("%3c") || lower.contains("%3e") || lower.contains("%00") {
346 return Ok(false);
347 }
348 if lower.contains("javascript:")
349 || lower.contains("data:")
350 || lower.contains("file:")
351 || lower.contains("jndi:")
352 {
353 return Ok(false);
354 }
355 if input.contains("${") || input.contains("{{") {
356 return Ok(false);
357 }
358 if input.contains("../") || input.contains("..\\") {
359 return Ok(false);
360 }
361 if input.contains('\0') {
362 return Ok(false);
363 }
364 if lower.contains("; drop")
365 || lower.contains(";drop")
366 || lower.contains("' drop")
367 || lower.contains("'; drop")
368 || lower.contains("--")
369 {
370 return Ok(false);
371 }
372
373 Ok(true)
374 }
375
376 pub async fn get_user_info(&self, user_id: &str) -> Result<UserInfo> {
384 debug!("Getting user info for '{}'", user_id);
385
386 let key = format!("user:{}", user_id);
387 if let Some(data) = self.storage.get_kv(&key).await? {
388 let user_data: serde_json::Value = serde_json::from_slice(&data)
389 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
390
391 Ok(UserInfo {
392 id: user_data["user_id"].as_str().unwrap_or(user_id).to_string(),
393 username: user_data["username"].as_str().unwrap_or("").to_string(),
394 email: user_data["email"].as_str().map(String::from),
395 name: user_data["name"].as_str().map(String::from),
396 roles: user_data["roles"]
397 .as_array()
398 .map(|arr| {
399 arr.iter()
400 .filter_map(|v| v.as_str().map(String::from))
401 .collect::<Vec<_>>()
402 })
403 .unwrap_or_else(|| vec!["user".to_string()])
404 .into(),
405 active: user_data["active"].as_bool().unwrap_or(true),
406 email_verified: user_data["email_verified"].as_bool().unwrap_or(false),
407 attributes: crate::types::UserAttributes::empty(),
408 })
409 } else {
410 Err(AuthError::validation(format!("User '{user_id}' not found")))
411 }
412 }
413
414 pub async fn list_users(
422 &self,
423 limit: Option<usize>,
424 offset: Option<usize>,
425 active_only: bool,
426 ) -> Result<Vec<UserInfo>> {
427 let bytes = self.storage.get_kv("users:index").await?;
428 let user_ids: Vec<String> = match bytes {
429 Some(bytes) => serde_json::from_slice(&bytes)
430 .map_err(|e| AuthError::internal(format!("Failed to parse user index: {e}")))?,
431 None => return Ok(Vec::new()),
432 };
433
434 let skip = offset.unwrap_or(0);
435 let take = limit.unwrap_or(usize::MAX);
436 let mut users = Vec::new();
437
438 for user_id in user_ids.into_iter().skip(skip) {
439 let user = self.get_user_info(&user_id).await?;
440 if active_only && !user.active {
441 continue;
442 }
443 users.push(user);
444 if users.len() >= take {
445 break;
446 }
447 }
448
449 Ok(users)
450 }
451
452 pub async fn user_exists(&self, user_id: &str) -> Result<bool> {
461 debug!("Checking if user '{}' exists", user_id);
462
463 if user_id.is_empty() {
464 return Ok(false);
465 }
466
467 let key = format!("user:{}", user_id);
468 Ok(self.storage.get_kv(&key).await?.is_some())
469 }
470
471 pub async fn register_user(
483 &self,
484 username: &str,
485 email: &str,
486 password: &str,
487 ) -> Result<String> {
488 debug!("Registering new user: {}", username);
489
490 let username_key = format!("user:username:{}", username);
491 if self.storage.get_kv(&username_key).await?.is_some() {
492 return Err(AuthError::validation("Username already exists".to_string()));
493 }
494
495 let email_key = format!("user:email:{}", email);
496 if self.storage.get_kv(&email_key).await?.is_some() {
497 return Err(AuthError::validation("Email already exists".to_string()));
498 }
499
500 let user_id = crate::utils::string::generate_id(Some("user"));
501
502 let password_hash = bcrypt::hash(password, bcrypt::DEFAULT_COST)
503 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
504
505 let user_data = serde_json::json!({
506 "user_id": user_id,
507 "username": username,
508 "email": email,
509 "password_hash": password_hash,
510 "roles": ["user"],
511 "active": true,
512 "email_verified": false,
513 "created_at": chrono::Utc::now().to_rfc3339(),
514 });
515
516 let user_key = format!("user:{}", user_id);
517 self.storage
518 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
519 .await?;
520
521 self.storage
522 .store_kv(&username_key, user_id.as_bytes(), None)
523 .await?;
524 self.storage
525 .store_kv(&email_key, user_id.as_bytes(), None)
526 .await?;
527
528 let index_key = "users:index";
530 let mut ids: Vec<String> = match self.storage.get_kv(index_key).await? {
531 Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
532 None => vec![],
533 };
534 ids.push(user_id.clone());
535 if let Ok(idx_json) = serde_json::to_vec(&ids)
536 && let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await
537 {
538 warn!("Failed to update user index during registration: {}", e);
539 }
540
541 let creds_key = format!("user:credentials:{}", username);
543 let creds_hash = match crate::utils::password::hash_password_argon2id(password) {
544 Ok(h) => h,
545 Err(e) => {
546 warn!("Failed to hash credentials for user '{}': {}", username, e);
547 return Ok(user_id);
548 }
549 };
550 let creds_data = serde_json::json!({
551 "user_id": user_id,
552 "username": username,
553 "email": email,
554 "password_hash": creds_hash,
555 "created_at": chrono::Utc::now().to_rfc3339(),
556 });
557 if let Err(e) = self
558 .storage
559 .store_kv(&creds_key, creds_data.to_string().as_bytes(), None)
560 .await
561 {
562 warn!("Failed to store credentials for user '{}': {}", username, e);
563 }
564
565 info!("User '{}' registered successfully", username);
566 Ok(user_id)
567 }
568
569 pub async fn delete_user(&self, username: &str) -> Result<()> {
576 debug!("Deleting user: {}", username);
577
578 let username_key = format!("user:username:{}", username);
579 let user_id_data = self
580 .storage
581 .get_kv(&username_key)
582 .await?
583 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
584
585 let user_id = String::from_utf8(user_id_data)
586 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
587
588 let user_key = format!("user:{}", user_id);
590 if let Some(user_data_bytes) = self.storage.get_kv(&user_key).await?
591 && let Ok(user_json_str) = String::from_utf8(user_data_bytes)
592 && let Ok(user_data) = serde_json::from_str::<serde_json::Value>(&user_json_str)
593 && let Some(email) = user_data.get("email").and_then(|v| v.as_str())
594 && let Err(e) = self
595 .storage
596 .delete_kv(&format!("user:email:{}", email))
597 .await
598 {
599 warn!(
600 "Failed to delete email index for user '{}': {}",
601 username, e
602 );
603 }
604
605 let index_key = "users:index";
607 if let Ok(Some(bytes)) = self.storage.get_kv(index_key).await {
608 let mut ids: Vec<String> = serde_json::from_slice(&bytes).unwrap_or_default();
609 ids.retain(|id| id != &user_id);
610 if let Ok(idx_json) = serde_json::to_vec(&ids)
611 && let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await
612 {
613 warn!(
614 "Failed to update user index during deletion of '{}': {}",
615 username, e
616 );
617 }
618 }
619
620 if let Err(e) = self.storage.delete_kv(&user_key).await {
621 warn!("Failed to delete user record for '{}': {}", username, e);
622 }
623 if let Err(e) = self.storage.delete_kv(&username_key).await {
624 warn!("Failed to delete username index for '{}': {}", username, e);
625 }
626 if let Err(e) = self
627 .storage
628 .delete_kv(&format!("user:credentials:{}", username))
629 .await
630 {
631 warn!("Failed to delete credentials for '{}': {}", username, e);
632 }
633 if let Err(e) = self
634 .storage
635 .delete_kv(&format!("user:{}:totp_secret", user_id))
636 .await
637 {
638 warn!("Failed to delete TOTP secret for '{}': {}", username, e);
639 }
640 if let Err(e) = self
641 .storage
642 .delete_kv(&format!("user:{}:backup_codes", user_id))
643 .await
644 {
645 warn!("Failed to delete backup codes for '{}': {}", username, e);
646 }
647 if let Err(e) = self
648 .storage
649 .delete_kv(&crate::auth_modular::mfa::backup_codes::store_key(&user_id))
650 .await
651 {
652 warn!("Failed to delete backup codes for '{}': {}", username, e);
653 }
654
655 crate::account_state::revoke_user_credentials(&*self.storage, &user_id).await?;
657
658 info!("User '{}' deleted successfully", username);
659 Ok(())
660 }
661
662 pub async fn delete_user_by_id(&self, user_id: &str) -> Result<()> {
669 let username = self.get_username_by_id(user_id).await?;
670 self.delete_user(&username).await
671 }
672
673 pub async fn update_user_roles(&self, user_id: &str, roles: &[String]) -> Result<()> {
680 let user_key = format!("user:{}", user_id);
681 let bytes = self
682 .storage
683 .get_kv(&user_key)
684 .await?
685 .ok_or(AuthError::UserNotFound)?;
686 let mut user_data: serde_json::Value =
687 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
688 user_data["roles"] = serde_json::json!(roles);
689 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
690 self.storage
691 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
692 .await?;
693 info!("Roles updated for user '{}'", user_id);
694 Ok(())
695 }
696
697 pub async fn set_user_active(&self, user_id: &str, active: bool) -> Result<()> {
704 let user_key = format!("user:{}", user_id);
705 let bytes = self
706 .storage
707 .get_kv(&user_key)
708 .await?
709 .ok_or(AuthError::UserNotFound)?;
710 let mut user_data: serde_json::Value =
711 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
712 user_data["active"] = serde_json::json!(active);
713 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
714 self.storage
715 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
716 .await?;
717 if !active {
718 crate::account_state::revoke_user_credentials(&*self.storage, user_id).await?;
719 }
720 info!("User '{}' active status set to {}", user_id, active);
721 Ok(())
722 }
723
724 pub async fn update_user_email(&self, user_id: &str, email: &str) -> Result<()> {
731 let user_key = format!("user:{}", user_id);
732 let bytes = self
733 .storage
734 .get_kv(&user_key)
735 .await?
736 .ok_or(AuthError::UserNotFound)?;
737 let mut user_data: serde_json::Value =
738 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
739
740 let new_email_key = format!("user:email:{}", email);
741 if let Some(existing_user_id) = self.storage.get_kv(&new_email_key).await? {
742 let existing_user_id = String::from_utf8(existing_user_id)
743 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {e}")))?;
744 if existing_user_id != user_id {
745 return Err(AuthError::validation("Email already exists".to_string()));
746 }
747 }
748
749 if let Some(old_email) = user_data.get("email").and_then(|value| value.as_str())
750 && old_email != email
751 {
752 self.storage
753 .delete_kv(&format!("user:email:{}", old_email))
754 .await?;
755 }
756
757 user_data["email"] = serde_json::json!(email);
758 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
759
760 self.storage
761 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
762 .await?;
763 self.storage
764 .store_kv(&new_email_key, user_id.as_bytes(), None)
765 .await?;
766
767 Ok(())
768 }
769
770 pub async fn verify_user_password(&self, user_id: &str, password: &str) -> Result<bool> {
778 let user_key = format!("user:{}", user_id);
779 let bytes = self
780 .storage
781 .get_kv(&user_key)
782 .await?
783 .ok_or(AuthError::UserNotFound)?;
784 let user_data: serde_json::Value =
785 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
786 let hash = user_data["password_hash"]
787 .as_str()
788 .ok_or_else(|| AuthError::internal("User has no password hash".to_string()))?;
789 bcrypt::verify(password, hash)
790 .map_err(|e| AuthError::crypto(format!("Password verification failed: {}", e)))
791 }
792
793 pub async fn get_username_by_id(&self, user_id: &str) -> Result<String> {
800 let user_key = format!("user:{}", user_id);
801 let bytes = self
802 .storage
803 .get_kv(&user_key)
804 .await?
805 .ok_or(AuthError::UserNotFound)?;
806 let user_data: serde_json::Value =
807 serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
808 user_data["username"]
809 .as_str()
810 .map(|s| s.to_string())
811 .ok_or_else(|| AuthError::internal("User has no username field".to_string()))
812 }
813
814 pub async fn username_exists(&self, username: &str) -> Result<bool> {
823 Ok(self
824 .storage
825 .get_kv(&format!("user:username:{}", username))
826 .await?
827 .is_some())
828 }
829
830 pub async fn email_exists(&self, email: &str) -> Result<bool> {
839 Ok(self
840 .storage
841 .get_kv(&format!("user:email:{}", email))
842 .await?
843 .is_some())
844 }
845
846 pub async fn get_user_by_username(
854 &self,
855 username: &str,
856 ) -> Result<HashMap<String, serde_json::Value>> {
857 let username_key = format!("user:username:{}", username);
858 let user_id_data = self
859 .storage
860 .get_kv(&username_key)
861 .await?
862 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
863 let user_id = String::from_utf8(user_id_data)
864 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
865 let user_key = format!("user:{}", user_id);
866 let user_data = self
867 .storage
868 .get_kv(&user_key)
869 .await?
870 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
871 let user_obj: serde_json::Value = serde_json::from_slice(&user_data)
872 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
873 if let Some(obj) = user_obj.as_object() {
874 Ok(obj
875 .into_iter()
876 .map(|(k, v)| (k.clone(), v.clone()))
877 .collect())
878 } else {
879 Err(AuthError::validation(
880 "Invalid user data structure".to_string(),
881 ))
882 }
883 }
884
885 pub async fn get_user_profile(
893 &self,
894 user_id: &str,
895 ) -> Result<crate::providers::ProviderProfile> {
896 let user_key = format!("user:{}", user_id);
897 if let Ok(Some(bytes)) = self.storage.get_kv(&user_key).await
898 && let Ok(user_data) = serde_json::from_slice::<serde_json::Value>(&bytes)
899 {
900 let username = user_data["username"].as_str().map(|s| s.to_string());
901 let email = user_data["email"].as_str().map(|s| s.to_string());
902 let name = user_data["name"].as_str().map(|s| s.to_string());
903 let email_verified = user_data["email_verified"].as_bool();
904
905 let mut additional_data = std::collections::HashMap::new();
906 if let Some(obj) = user_data.as_object() {
907 for (k, v) in obj {
908 match k.as_str() {
909 "user_id" | "username" | "email" | "name" | "email_verified"
910 | "password_hash" | "created_at" | "updated_at" => {}
911 _ => {
912 additional_data.insert(k.clone(), v.clone());
913 }
914 }
915 }
916 }
917
918 return Ok(crate::providers::ProviderProfile {
919 id: Some(user_id.to_string()),
920 provider: Some("local".to_string()),
921 username,
922 name,
923 email,
924 email_verified,
925 picture: None,
926 locale: None,
927 additional_data,
928 });
929 }
930 Err(AuthError::UserNotFound)
931 }
932
933 pub async fn get_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
941 let user_key = format!("user:{}", user_id);
942 if let Ok(Some(data)) = self.storage.get_kv(&user_key).await
943 && let Ok(v) = serde_json::from_slice::<serde_json::Value>(&data)
944 && let Some(arr) = v.get("roles").and_then(|r| r.as_array())
945 {
946 let roles: Vec<String> = arr
947 .iter()
948 .filter_map(|v| v.as_str().map(String::from))
949 .collect();
950 if !roles.is_empty() {
951 return Ok(roles);
952 }
953 }
954 Ok(vec!["user".to_string()])
955 }
956
957 pub async fn verify_login_credentials(
972 &self,
973 username: &str,
974 password: &str,
975 ) -> Result<Option<CredentialCheckResult>> {
976 use crate::utils::password::verify_password_argon2id;
977
978 if username.is_empty() || password.is_empty() {
979 return Ok(None);
980 }
981
982 let user_key = format!("user:credentials:{username}");
983 let stored_bytes = match self.storage.get_kv(&user_key).await? {
984 Some(bytes) => bytes,
985 None => {
986 let _ = verify_password_argon2id(
988 password,
989 "$argon2id$v=19$m=19456,t=2,p=1$dGVzdHNhbHRmb3J0aW1pbmc$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
990 );
991 return Ok(None);
992 }
993 };
994
995 let user_data_str = String::from_utf8(stored_bytes)
996 .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
997 let user_data: serde_json::Value = serde_json::from_str(&user_data_str)
998 .map_err(|e| AuthError::internal(format!("Failed to parse user JSON: {e}")))?;
999
1000 let password_hash = user_data["password_hash"].as_str().ok_or_else(|| {
1001 AuthError::internal("Missing password hash in user record".to_string())
1002 })?;
1003
1004 if !verify_password_argon2id(password, password_hash).unwrap_or(false) {
1005 return Ok(None);
1006 }
1007
1008 let user_id = user_data["user_id"]
1009 .as_str()
1010 .ok_or_else(|| AuthError::internal("Missing user_id in user record".to_string()))?
1011 .to_string();
1012
1013 let canonical_key = format!("user:{}", user_id);
1015 if let Ok(Some(canonical_bytes)) = self.storage.get_kv(&canonical_key).await
1016 && let Ok(canonical_str) = String::from_utf8(canonical_bytes)
1017 && let Ok(canonical_data) = serde_json::from_str::<serde_json::Value>(&canonical_str)
1018 && !canonical_data["active"].as_bool().unwrap_or(true)
1019 {
1020 return Ok(None);
1021 }
1022
1023 let mfa_enabled = matches!(
1024 self.storage
1025 .get_kv(&format!("mfa_enabled:{}", user_id))
1026 .await,
1027 Ok(Some(_))
1028 );
1029
1030 Ok(Some(CredentialCheckResult {
1031 user_id,
1032 mfa_enabled,
1033 }))
1034 }
1035
1036 pub async fn update_user_password(&self, username: &str, new_password: &str) -> Result<()> {
1043 debug!("Updating password for user: {}", username);
1044
1045 crate::utils::validation::validate_password(new_password)
1046 .map_err(|e| AuthError::validation(format!("Password validation failed: {e}")))?;
1047
1048 let username_key = format!("user:username:{}", username);
1049 let user_id_data = self
1050 .storage
1051 .get_kv(&username_key)
1052 .await?
1053 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
1054 let user_id = String::from_utf8(user_id_data)
1055 .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
1056
1057 let user_key = format!("user:{}", user_id);
1058 let user_bytes = self
1059 .storage
1060 .get_kv(&user_key)
1061 .await?
1062 .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
1063 let mut user_data: serde_json::Value = serde_json::from_slice(&user_bytes)
1064 .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
1065
1066 let password_hash = bcrypt::hash(new_password, bcrypt::DEFAULT_COST)
1067 .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
1068 user_data["password_hash"] = serde_json::json!(password_hash);
1069 user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
1070 self.storage
1071 .store_kv(&user_key, user_data.to_string().as_bytes(), None)
1072 .await?;
1073
1074 let creds_key = format!("user:credentials:{}", username);
1076 let creds_hash = crate::utils::password::hash_password_argon2id(new_password)
1077 .map_err(|e| AuthError::crypto(format!("Failed to hash login credentials: {e}")))?;
1078 let creds_bytes =
1079 self.storage.get_kv(&creds_key).await?.ok_or_else(|| {
1080 AuthError::internal("Login credentials record not found".to_string())
1081 })?;
1082 let mut creds: serde_json::Value = serde_json::from_slice(&creds_bytes)
1083 .map_err(|e| AuthError::internal(format!("Failed to parse credentials record: {e}")))?;
1084 creds["password_hash"] = serde_json::json!(creds_hash);
1085 creds["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
1086 self.storage
1087 .store_kv(&creds_key, creds.to_string().as_bytes(), None)
1088 .await?;
1089
1090 crate::account_state::revoke_user_credentials(&*self.storage, &user_id).await?;
1092
1093 info!("Password updated for user: {}", username);
1094 Ok(())
1095 }
1096
1097 pub async fn update_user_password_by_id(
1104 &self,
1105 user_id: &str,
1106 new_password: &str,
1107 ) -> Result<()> {
1108 let username = self.get_username_by_id(user_id).await?;
1109 self.update_user_password(&username, new_password).await
1110 }
1111}
1112
1113#[cfg(test)]
1114mod tests {
1115 use super::*;
1116 use crate::storage::MemoryStorage;
1117
1118 fn make_manager() -> UserManager {
1119 UserManager::new(Arc::new(MemoryStorage::new()))
1120 }
1121
1122 #[tokio::test]
1125 async fn test_register_user_success() {
1126 let mgr = make_manager();
1127 let id = mgr
1128 .register_user("alice", "alice@example.com", "StrongP@ss1!")
1129 .await
1130 .unwrap();
1131 assert!(id.starts_with("user"));
1132 }
1133
1134 #[tokio::test]
1135 async fn test_register_user_duplicate_username() {
1136 let mgr = make_manager();
1137 mgr.register_user("bob", "bob@example.com", "StrongP@ss1!")
1138 .await
1139 .unwrap();
1140 let err = mgr
1141 .register_user("bob", "bob2@example.com", "StrongP@ss1!")
1142 .await;
1143 assert!(err.is_err());
1144 }
1145
1146 #[tokio::test]
1147 async fn test_register_user_duplicate_email() {
1148 let mgr = make_manager();
1149 mgr.register_user("carol", "dup@example.com", "StrongP@ss1!")
1150 .await
1151 .unwrap();
1152 let err = mgr
1153 .register_user("carol2", "dup@example.com", "StrongP@ss1!")
1154 .await;
1155 assert!(err.is_err());
1156 }
1157
1158 #[tokio::test]
1161 async fn test_get_user_info_success() {
1162 let mgr = make_manager();
1163 let id = mgr
1164 .register_user("dave", "dave@example.com", "StrongP@ss1!")
1165 .await
1166 .unwrap();
1167 let info = mgr.get_user_info(&id).await.unwrap();
1168 assert_eq!(info.username, "dave");
1169 assert!(info.active);
1170 }
1171
1172 #[tokio::test]
1173 async fn test_get_user_info_not_found() {
1174 let mgr = make_manager();
1175 assert!(mgr.get_user_info("nonexistent").await.is_err());
1176 }
1177
1178 #[tokio::test]
1181 async fn test_user_exists_true() {
1182 let mgr = make_manager();
1183 let id = mgr
1184 .register_user("eve", "eve@example.com", "StrongP@ss1!")
1185 .await
1186 .unwrap();
1187 assert!(mgr.user_exists(&id).await.unwrap());
1188 }
1189
1190 #[tokio::test]
1191 async fn test_user_exists_false() {
1192 let mgr = make_manager();
1193 assert!(!mgr.user_exists("nobody").await.unwrap());
1194 }
1195
1196 #[tokio::test]
1197 async fn test_user_exists_empty_id() {
1198 let mgr = make_manager();
1199 assert!(!mgr.user_exists("").await.unwrap());
1200 }
1201
1202 #[tokio::test]
1205 async fn test_delete_user_success() {
1206 let mgr = make_manager();
1207 let id = mgr
1208 .register_user("frank", "frank@example.com", "StrongP@ss1!")
1209 .await
1210 .unwrap();
1211 mgr.delete_user("frank").await.unwrap();
1212 assert!(!mgr.user_exists(&id).await.unwrap());
1213 }
1214
1215 #[tokio::test]
1216 async fn test_delete_user_not_found() {
1217 let mgr = make_manager();
1218 assert!(mgr.delete_user("ghost").await.is_err());
1219 }
1220
1221 #[tokio::test]
1222 async fn test_delete_user_by_id() {
1223 let mgr = make_manager();
1224 let id = mgr
1225 .register_user("gina", "gina@example.com", "StrongP@ss1!")
1226 .await
1227 .unwrap();
1228 mgr.delete_user_by_id(&id).await.unwrap();
1229 assert!(!mgr.user_exists(&id).await.unwrap());
1230 }
1231
1232 #[tokio::test]
1235 async fn test_list_users_empty() {
1236 let mgr = make_manager();
1237 let users = mgr.list_users(None, None, false).await.unwrap();
1238 assert!(users.is_empty());
1239 }
1240
1241 #[tokio::test]
1242 async fn test_list_users_with_limit_and_offset() {
1243 let mgr = make_manager();
1244 mgr.register_user("u1", "u1@example.com", "StrongP@ss1!")
1245 .await
1246 .unwrap();
1247 mgr.register_user("u2", "u2@example.com", "StrongP@ss1!")
1248 .await
1249 .unwrap();
1250 mgr.register_user("u3", "u3@example.com", "StrongP@ss1!")
1251 .await
1252 .unwrap();
1253 let page = mgr.list_users(Some(1), Some(1), false).await.unwrap();
1254 assert_eq!(page.len(), 1);
1255 }
1256
1257 #[tokio::test]
1260 async fn test_verify_password_correct() {
1261 let mgr = make_manager();
1262 let id = mgr
1263 .register_user("hank", "hank@example.com", "StrongP@ss1!")
1264 .await
1265 .unwrap();
1266 assert!(mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1267 }
1268
1269 #[tokio::test]
1270 async fn test_verify_password_incorrect() {
1271 let mgr = make_manager();
1272 let id = mgr
1273 .register_user("ivan", "ivan@example.com", "StrongP@ss1!")
1274 .await
1275 .unwrap();
1276 assert!(!mgr.verify_user_password(&id, "wrong").await.unwrap());
1277 }
1278
1279 #[tokio::test]
1280 async fn test_verify_password_user_not_found() {
1281 let mgr = make_manager();
1282 assert!(mgr.verify_user_password("ghost", "x").await.is_err());
1283 }
1284
1285 #[tokio::test]
1288 async fn test_update_password() {
1289 let mgr = make_manager();
1290 let id = mgr
1291 .register_user("jack", "jack@example.com", "StrongP@ss1!")
1292 .await
1293 .unwrap();
1294 mgr.update_user_password("jack", "NewStr0ng!Pass")
1295 .await
1296 .unwrap();
1297 assert!(
1298 mgr.verify_user_password(&id, "NewStr0ng!Pass")
1299 .await
1300 .unwrap()
1301 );
1302 assert!(!mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1303 }
1304
1305 #[tokio::test]
1306 async fn test_update_password_user_not_found() {
1307 let mgr = make_manager();
1308 assert!(
1309 mgr.update_user_password("ghost", "NewStr0ng!Pass")
1310 .await
1311 .is_err()
1312 );
1313 }
1314
1315 #[tokio::test]
1318 async fn test_update_user_roles() {
1319 let mgr = make_manager();
1320 let id = mgr
1321 .register_user("kate", "kate@example.com", "StrongP@ss1!")
1322 .await
1323 .unwrap();
1324 mgr.update_user_roles(&id, &["admin".into(), "user".into()])
1325 .await
1326 .unwrap();
1327 let info = mgr.get_user_info(&id).await.unwrap();
1328 assert!(info.roles.contains("admin"));
1329 }
1330
1331 #[tokio::test]
1332 async fn test_update_user_roles_not_found() {
1333 let mgr = make_manager();
1334 assert!(
1335 mgr.update_user_roles("ghost", &["admin".into()])
1336 .await
1337 .is_err()
1338 );
1339 }
1340
1341 #[tokio::test]
1344 async fn test_set_user_active_disable() {
1345 let mgr = make_manager();
1346 let id = mgr
1347 .register_user("leon", "leon@example.com", "StrongP@ss1!")
1348 .await
1349 .unwrap();
1350 mgr.set_user_active(&id, false).await.unwrap();
1351 let info = mgr.get_user_info(&id).await.unwrap();
1352 assert!(!info.active);
1353 }
1354
1355 #[tokio::test]
1356 async fn test_set_user_active_not_found() {
1357 let mgr = make_manager();
1358 assert!(mgr.set_user_active("ghost", false).await.is_err());
1359 }
1360
1361 #[tokio::test]
1364 async fn test_update_user_email() {
1365 let mgr = make_manager();
1366 let id = mgr
1367 .register_user("mary", "mary@example.com", "StrongP@ss1!")
1368 .await
1369 .unwrap();
1370 mgr.update_user_email(&id, "mary_new@example.com")
1371 .await
1372 .unwrap();
1373 let info = mgr.get_user_info(&id).await.unwrap();
1374 assert_eq!(info.email.as_deref(), Some("mary_new@example.com"));
1375 }
1376
1377 #[tokio::test]
1378 async fn test_update_user_email_already_taken() {
1379 let mgr = make_manager();
1380 mgr.register_user("n1", "taken@example.com", "StrongP@ss1!")
1381 .await
1382 .unwrap();
1383 let id2 = mgr
1384 .register_user("n2", "n2@example.com", "StrongP@ss1!")
1385 .await
1386 .unwrap();
1387 assert!(
1388 mgr.update_user_email(&id2, "taken@example.com")
1389 .await
1390 .is_err()
1391 );
1392 }
1393
1394 #[tokio::test]
1397 async fn test_create_and_validate_api_key() {
1398 let mgr = make_manager();
1399 let id = mgr
1400 .register_user("oscar", "oscar@example.com", "StrongP@ss1!")
1401 .await
1402 .unwrap();
1403 let key = mgr.create_api_key(&id, None).await.unwrap();
1404 assert!(key.starts_with("ak_"));
1405 let info = mgr.validate_api_key(&key).await.unwrap();
1406 assert_eq!(info.id, id);
1407 }
1408
1409 #[tokio::test]
1410 async fn test_validate_api_key_invalid() {
1411 let mgr = make_manager();
1412 assert!(mgr.validate_api_key("bad_key").await.is_err());
1413 }
1414
1415 #[tokio::test]
1416 async fn test_revoke_api_key() {
1417 let mgr = make_manager();
1418 let id = mgr
1419 .register_user("pat", "pat@example.com", "StrongP@ss1!")
1420 .await
1421 .unwrap();
1422 let key = mgr.create_api_key(&id, None).await.unwrap();
1423 mgr.revoke_api_key(&key).await.unwrap();
1424 assert!(mgr.validate_api_key(&key).await.is_err());
1425 }
1426
1427 #[tokio::test]
1428 async fn test_revoke_api_key_not_found() {
1429 let mgr = make_manager();
1430 assert!(mgr.revoke_api_key("nonexistent").await.is_err());
1431 }
1432
1433 #[tokio::test]
1436 async fn test_validate_username_valid() {
1437 let mgr = make_manager();
1438 assert!(mgr.validate_username("good_user-1").await.unwrap());
1439 }
1440
1441 #[tokio::test]
1442 async fn test_validate_username_too_short() {
1443 let mgr = make_manager();
1444 assert!(!mgr.validate_username("ab").await.unwrap());
1445 }
1446
1447 #[tokio::test]
1448 async fn test_validate_username_special_chars() {
1449 let mgr = make_manager();
1450 assert!(!mgr.validate_username("user@name").await.unwrap());
1451 }
1452
1453 #[tokio::test]
1456 async fn test_validate_display_name_valid() {
1457 let mgr = make_manager();
1458 assert!(mgr.validate_display_name("Alice Bob").await.unwrap());
1459 }
1460
1461 #[tokio::test]
1462 async fn test_validate_display_name_empty() {
1463 let mgr = make_manager();
1464 assert!(!mgr.validate_display_name("").await.unwrap());
1465 }
1466
1467 #[tokio::test]
1468 async fn test_validate_display_name_only_whitespace() {
1469 let mgr = make_manager();
1470 assert!(!mgr.validate_display_name(" ").await.unwrap());
1471 }
1472
1473 #[tokio::test]
1476 async fn test_validate_password_strong() {
1477 let mgr = make_manager();
1478 assert!(
1479 mgr.validate_password_strength("C0mpl3x!P@ssw0rd")
1480 .await
1481 .unwrap()
1482 );
1483 }
1484
1485 #[tokio::test]
1486 async fn test_validate_password_weak() {
1487 let mgr = make_manager();
1488 assert!(!mgr.validate_password_strength("123").await.unwrap());
1489 }
1490
1491 #[tokio::test]
1494 async fn test_validate_user_input_clean() {
1495 let mgr = make_manager();
1496 assert!(mgr.validate_user_input("Hello World 123").await.unwrap());
1497 }
1498
1499 #[tokio::test]
1500 async fn test_validate_user_input_html_tags() {
1501 let mgr = make_manager();
1502 assert!(
1503 !mgr.validate_user_input("<script>alert(1)</script>")
1504 .await
1505 .unwrap()
1506 );
1507 }
1508
1509 #[tokio::test]
1510 async fn test_validate_user_input_sql_injection() {
1511 let mgr = make_manager();
1512 assert!(
1513 !mgr.validate_user_input("'; drop table users--")
1514 .await
1515 .unwrap()
1516 );
1517 }
1518
1519 #[tokio::test]
1520 async fn test_validate_user_input_template_injection() {
1521 let mgr = make_manager();
1522 assert!(!mgr.validate_user_input("${evil}").await.unwrap());
1523 }
1524
1525 #[tokio::test]
1526 async fn test_validate_user_input_path_traversal() {
1527 let mgr = make_manager();
1528 assert!(!mgr.validate_user_input("../../etc/passwd").await.unwrap());
1529 }
1530
1531 #[tokio::test]
1532 async fn test_validate_user_input_javascript_uri() {
1533 let mgr = make_manager();
1534 assert!(
1535 !mgr.validate_user_input("javascript:alert(1)")
1536 .await
1537 .unwrap()
1538 );
1539 }
1540
1541 #[tokio::test]
1542 async fn test_validate_user_input_empty() {
1543 let mgr = make_manager();
1544 assert!(!mgr.validate_user_input("").await.unwrap());
1545 }
1546
1547 #[tokio::test]
1548 async fn test_validate_user_input_encoded_tags() {
1549 let mgr = make_manager();
1550 assert!(!mgr.validate_user_input("%3cscript%3e").await.unwrap());
1551 }
1552
1553 #[tokio::test]
1556 async fn test_username_exists() {
1557 let mgr = make_manager();
1558 mgr.register_user("quinn", "quinn@example.com", "StrongP@ss1!")
1559 .await
1560 .unwrap();
1561 assert!(mgr.username_exists("quinn").await.unwrap());
1562 assert!(!mgr.username_exists("noone").await.unwrap());
1563 }
1564
1565 #[tokio::test]
1566 async fn test_email_exists() {
1567 let mgr = make_manager();
1568 mgr.register_user("ross", "ross@example.com", "StrongP@ss1!")
1569 .await
1570 .unwrap();
1571 assert!(mgr.email_exists("ross@example.com").await.unwrap());
1572 assert!(!mgr.email_exists("nobody@example.com").await.unwrap());
1573 }
1574
1575 #[tokio::test]
1578 async fn test_get_user_by_username() {
1579 let mgr = make_manager();
1580 mgr.register_user("sam", "sam@example.com", "StrongP@ss1!")
1581 .await
1582 .unwrap();
1583 let data = mgr.get_user_by_username("sam").await.unwrap();
1584 assert_eq!(data["username"].as_str(), Some("sam"));
1585 }
1586
1587 #[tokio::test]
1588 async fn test_get_user_by_username_not_found() {
1589 let mgr = make_manager();
1590 assert!(mgr.get_user_by_username("ghost").await.is_err());
1591 }
1592
1593 #[tokio::test]
1596 async fn test_get_user_profile() {
1597 let mgr = make_manager();
1598 let id = mgr
1599 .register_user("tina", "tina@example.com", "StrongP@ss1!")
1600 .await
1601 .unwrap();
1602 let profile = mgr.get_user_profile(&id).await.unwrap();
1603 assert_eq!(profile.username.as_deref(), Some("tina"));
1604 assert_eq!(profile.email.as_deref(), Some("tina@example.com"));
1605 assert!(!profile.additional_data.contains_key("password_hash"));
1607 }
1608
1609 #[tokio::test]
1610 async fn test_get_user_profile_not_found() {
1611 let mgr = make_manager();
1612 assert!(mgr.get_user_profile("ghost").await.is_err());
1613 }
1614
1615 #[tokio::test]
1618 async fn test_get_user_roles_default() {
1619 let mgr = make_manager();
1620 let id = mgr
1621 .register_user("uma", "uma@example.com", "StrongP@ss1!")
1622 .await
1623 .unwrap();
1624 let roles = mgr.get_user_roles(&id).await.unwrap();
1625 assert!(roles.contains(&"user".to_string()));
1626 }
1627
1628 #[tokio::test]
1629 async fn test_get_user_roles_not_found_returns_default() {
1630 let mgr = make_manager();
1631 let roles = mgr.get_user_roles("ghost").await.unwrap();
1632 assert_eq!(roles, vec!["user".to_string()]);
1633 }
1634
1635 #[tokio::test]
1638 async fn test_verify_login_credentials_success() {
1639 let mgr = make_manager();
1640 mgr.register_user("vera", "vera@example.com", "StrongP@ss1!")
1641 .await
1642 .unwrap();
1643 let result = mgr
1644 .verify_login_credentials("vera", "StrongP@ss1!")
1645 .await
1646 .unwrap();
1647 assert!(result.is_some());
1648 assert!(!result.unwrap().mfa_enabled);
1649 }
1650
1651 #[tokio::test]
1652 async fn test_verify_login_credentials_wrong_password() {
1653 let mgr = make_manager();
1654 mgr.register_user("wanda", "wanda@example.com", "StrongP@ss1!")
1655 .await
1656 .unwrap();
1657 let result = mgr
1658 .verify_login_credentials("wanda", "wrong")
1659 .await
1660 .unwrap();
1661 assert!(result.is_none());
1662 }
1663
1664 #[tokio::test]
1665 async fn test_verify_login_credentials_unknown_user() {
1666 let mgr = make_manager();
1667 let result = mgr
1668 .verify_login_credentials("ghost", "StrongP@ss1!")
1669 .await
1670 .unwrap();
1671 assert!(result.is_none());
1672 }
1673
1674 #[tokio::test]
1675 async fn test_verify_login_credentials_empty_inputs() {
1676 let mgr = make_manager();
1677 assert!(
1678 mgr.verify_login_credentials("", "pass")
1679 .await
1680 .unwrap()
1681 .is_none()
1682 );
1683 assert!(
1684 mgr.verify_login_credentials("user", "")
1685 .await
1686 .unwrap()
1687 .is_none()
1688 );
1689 }
1690
1691 #[tokio::test]
1692 async fn test_verify_login_credentials_deactivated() {
1693 let mgr = make_manager();
1694 let id = mgr
1695 .register_user("xena", "xena@example.com", "StrongP@ss1!")
1696 .await
1697 .unwrap();
1698 mgr.set_user_active(&id, false).await.unwrap();
1699 let result = mgr
1700 .verify_login_credentials("xena", "StrongP@ss1!")
1701 .await
1702 .unwrap();
1703 assert!(result.is_none());
1704 }
1705
1706 #[tokio::test]
1709 async fn test_get_username_by_id() {
1710 let mgr = make_manager();
1711 let id = mgr
1712 .register_user("yara", "yara@example.com", "StrongP@ss1!")
1713 .await
1714 .unwrap();
1715 let username = mgr.get_username_by_id(&id).await.unwrap();
1716 assert_eq!(username, "yara");
1717 }
1718
1719 #[tokio::test]
1720 async fn test_get_username_by_id_not_found() {
1721 let mgr = make_manager();
1722 assert!(mgr.get_username_by_id("ghost").await.is_err());
1723 }
1724
1725 #[tokio::test]
1728 async fn test_list_users_active_only() {
1729 let mgr = make_manager();
1730 let id1 = mgr
1731 .register_user("active1", "active1@example.com", "StrongP@ss1!")
1732 .await
1733 .unwrap();
1734 let id2 = mgr
1735 .register_user("inactive1", "inactive1@example.com", "StrongP@ss1!")
1736 .await
1737 .unwrap();
1738 mgr.set_user_active(&id2, false).await.unwrap();
1739
1740 let all = mgr.list_users(None, None, false).await.unwrap();
1741 let active = mgr.list_users(None, None, true).await.unwrap();
1742 assert!(all.len() > active.len());
1743 assert!(active.iter().all(|u| u.active));
1744 assert!(all.iter().any(|u| u.id == id1));
1746 assert!(all.iter().any(|u| u.id == id2));
1747 }
1748}