Skip to main content

auth_framework/auth_modular/
user_manager.rs

1//! User management module
2
3use crate::errors::{AuthError, Result};
4use crate::storage::AuthStorage;
5use std::collections::HashMap;
6use std::sync::Arc;
7use tracing::{debug, info, warn};
8
9/// Canonical user information type shared with [`crate::auth::UserInfo`].
10pub type UserInfo = crate::auth::UserInfo;
11
12/// Result of a successful credential verification via [`UserManager::verify_login_credentials`].
13///
14/// # Example
15/// ```rust,ignore
16/// if let Some(result) = mgr.verify_login_credentials("alice", "pass").await? {
17///     println!("user_id={}, mfa={}", result.user_id, result.mfa_enabled);
18/// }
19/// ```
20pub struct CredentialCheckResult {
21    /// The verified user's ID.
22    pub user_id: String,
23    /// Whether the user has MFA enabled.
24    pub mfa_enabled: bool,
25}
26
27/// User manager for handling user operations.
28///
29/// # Example
30/// ```rust,ignore
31/// use auth_framework::auth_modular::UserManager;
32/// let um = UserManager::new(storage.clone());
33/// let uid = um.register_user("alice", "alice@example.com", "Str0ng!Pass").await?;
34/// ```
35pub struct UserManager {
36    storage: Arc<dyn AuthStorage>,
37}
38
39impl UserManager {
40    /// Create a new user manager.
41    ///
42    /// # Example
43    /// ```rust,ignore
44    /// let um = UserManager::new(storage.clone());
45    /// ```
46    pub fn new(storage: Arc<dyn AuthStorage>) -> Self {
47        Self { storage }
48    }
49
50    /// Create API key for a user.
51    ///
52    /// # Example
53    /// ```rust,ignore
54    /// let key = um.create_api_key("user-1", Some(Duration::from_secs(86400))).await?;
55    /// ```
56    pub async fn create_api_key(
57        &self,
58        user_id: &str,
59        expires_in: Option<std::time::Duration>,
60    ) -> Result<String> {
61        debug!("Creating API key for user '{}'", user_id);
62
63        // Generate a secure API key
64        let api_key = format!("ak_{}", crate::utils::crypto::generate_token(32));
65
66        // Store API key metadata
67        let key_data = serde_json::json!({
68            "user_id": user_id,
69            "created_at": chrono::Utc::now(),
70            "expires_at": expires_in.map(|d| chrono::Utc::now() + chrono::Duration::from_std(d).unwrap_or(chrono::Duration::days(365 * 10)))
71        });
72
73        let storage_key = format!("api_key:{}", api_key);
74        self.storage
75            .store_kv(&storage_key, key_data.to_string().as_bytes(), expires_in)
76            .await?;
77
78        info!("API key created for user '{}'", user_id);
79        Ok(api_key)
80    }
81
82    /// Validate API key and return user information.
83    ///
84    /// # Example
85    /// ```rust,ignore
86    /// let info = um.validate_api_key("ak_abc123").await?;
87    /// println!("user: {}", info.username);
88    /// ```
89    pub async fn validate_api_key(&self, api_key: &str) -> Result<UserInfo> {
90        debug!("Validating API key");
91
92        let storage_key = format!("api_key:{}", api_key);
93        if let Some(key_data) = self.storage.get_kv(&storage_key).await? {
94            let key_info: serde_json::Value = serde_json::from_slice(&key_data)?;
95
96            if let Some(user_id) = key_info["user_id"].as_str() {
97                // Check expiration
98                if let Some(expires_at_str) = key_info["expires_at"].as_str() {
99                    let expires_at: chrono::DateTime<chrono::Utc> = expires_at_str
100                        .parse()
101                        .map_err(|_| AuthError::token("Invalid API key expiration"))?;
102
103                    if chrono::Utc::now() > expires_at {
104                        return Err(AuthError::token("API key expired"));
105                    }
106                }
107
108                // Return user information
109                Ok(UserInfo {
110                    id: user_id.to_string(),
111                    username: format!("api_user_{}", user_id),
112                    email: None,
113                    name: None,
114                    roles: vec!["api_user".to_string()].into(),
115                    active: true,
116                    email_verified: false,
117                    attributes: crate::types::UserAttributes::empty(),
118                })
119            } else {
120                Err(AuthError::token("Invalid API key format"))
121            }
122        } else {
123            Err(AuthError::token("Invalid API key"))
124        }
125    }
126
127    /// Revoke API key.
128    ///
129    /// # Example
130    /// ```rust,ignore
131    /// um.revoke_api_key("ak_abc123").await?;
132    /// ```
133    pub async fn revoke_api_key(&self, api_key: &str) -> Result<()> {
134        debug!("Revoking API key");
135
136        let storage_key = format!("api_key:{}", api_key);
137        if self.storage.get_kv(&storage_key).await?.is_some() {
138            self.storage.delete_kv(&storage_key).await?;
139            info!("API key revoked");
140            Ok(())
141        } else {
142            Err(AuthError::token("API key not found"))
143        }
144    }
145
146    /// Validate username format.
147    ///
148    /// # Example
149    /// ```rust,ignore
150    /// assert!(um.validate_username("alice").await?);
151    /// assert!(!um.validate_username("").await?);
152    /// ```
153    pub async fn validate_username(&self, username: &str) -> Result<bool> {
154        debug!("Validating username format: '{}'", username);
155
156        let is_valid = username.len() >= 3
157            && username.len() <= 32
158            && username
159                .chars()
160                .all(|c| c.is_alphanumeric() || c == '_' || c == '-');
161
162        Ok(is_valid)
163    }
164
165    /// Validate display name format.
166    ///
167    /// # Example
168    /// ```rust,ignore
169    /// assert!(um.validate_display_name("Alice B.").await?);
170    /// ```
171    pub async fn validate_display_name(&self, display_name: &str) -> Result<bool> {
172        debug!("Validating display name format");
173
174        let is_valid = !display_name.is_empty()
175            && display_name.len() <= 100
176            && !display_name.trim().is_empty();
177
178        Ok(is_valid)
179    }
180
181    /// Validate password strength using security policy.
182    ///
183    /// Requires Strong or VeryStrong to protect production deployments.
184    ///
185    /// # Example
186    /// ```rust,ignore
187    /// assert!(um.validate_password_strength("C0mpl3x!Pa$$word").await?);
188    /// assert!(!um.validate_password_strength("weak").await?);
189    /// ```
190    pub async fn validate_password_strength(&self, password: &str) -> Result<bool> {
191        debug!("Validating password strength");
192        let strength = crate::utils::password::check_password_strength(password);
193        let is_valid = crate::utils::password::meets_production_strength(strength.level);
194        if !is_valid {
195            warn!(
196                "Password validation failed - Actual: {:?}, Feedback: {}",
197                strength.level,
198                strength.feedback.join(", ")
199            );
200        }
201        Ok(is_valid)
202    }
203
204    /// Validate user input for security.
205    ///
206    /// Combines a character whitelist with pattern checks for common injection
207    /// vectors. Rejects HTML tags, null bytes, path traversal sequences,
208    /// template injection markers, and dangerous URI schemes.
209    ///
210    /// # Example
211    /// ```rust,ignore
212    /// assert!(um.validate_user_input("hello world").await?);
213    /// assert!(!um.validate_user_input("<script>alert(1)</script>").await?);
214    /// ```
215    pub async fn validate_user_input(&self, input: &str) -> Result<bool> {
216        debug!("Validating user input");
217
218        if input.is_empty() || input.len() > 1000 {
219            return Ok(false);
220        }
221
222        // Character whitelist: reject control characters and angle brackets.
223        if !input.chars().all(|c| {
224            if c.is_control() {
225                matches!(c, ' ' | '\t' | '\n' | '\r')
226            } else {
227                !matches!(c, '<' | '>')
228            }
229        }) {
230            return Ok(false);
231        }
232
233        let lower = input.to_ascii_lowercase();
234        if lower.contains("%3c") || lower.contains("%3e") || lower.contains("%00") {
235            return Ok(false);
236        }
237        if lower.contains("javascript:")
238            || lower.contains("data:")
239            || lower.contains("file:")
240            || lower.contains("jndi:")
241        {
242            return Ok(false);
243        }
244        if input.contains("${") || input.contains("{{") {
245            return Ok(false);
246        }
247        if input.contains("../") || input.contains("..\\") {
248            return Ok(false);
249        }
250        if input.contains('\0') {
251            return Ok(false);
252        }
253        if lower.contains("; drop")
254            || lower.contains(";drop")
255            || lower.contains("' drop")
256            || lower.contains("'; drop")
257            || lower.contains("--")
258        {
259            return Ok(false);
260        }
261
262        Ok(true)
263    }
264
265    /// Get user information by ID.
266    ///
267    /// # Example
268    /// ```rust,ignore
269    /// let info = um.get_user_info("user-1").await?;
270    /// println!("username: {}", info.username);
271    /// ```
272    pub async fn get_user_info(&self, user_id: &str) -> Result<UserInfo> {
273        debug!("Getting user info for '{}'", user_id);
274
275        let key = format!("user:{}", user_id);
276        if let Some(data) = self.storage.get_kv(&key).await? {
277            let user_data: serde_json::Value = serde_json::from_slice(&data)
278                .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
279
280            Ok(UserInfo {
281                id: user_data["user_id"].as_str().unwrap_or(user_id).to_string(),
282                username: user_data["username"].as_str().unwrap_or("").to_string(),
283                email: user_data["email"].as_str().map(String::from),
284                name: user_data["name"].as_str().map(String::from),
285                roles: user_data["roles"]
286                    .as_array()
287                    .map(|arr| {
288                        arr.iter()
289                            .filter_map(|v| v.as_str().map(String::from))
290                            .collect::<Vec<_>>()
291                    })
292                    .unwrap_or_else(|| vec!["user".to_string()])
293                    .into(),
294                active: user_data["active"].as_bool().unwrap_or(true),
295                email_verified: user_data["email_verified"].as_bool().unwrap_or(false),
296                attributes: crate::types::UserAttributes::empty(),
297            })
298        } else {
299            Err(AuthError::validation(format!("User '{user_id}' not found")))
300        }
301    }
302
303    /// List users from the canonical user index.
304    ///
305    /// # Example
306    /// ```rust,ignore
307    /// let users = um.list_users(Some(10), Some(0), true).await?;
308    /// for u in &users { println!("{}", u.username); }
309    /// ```
310    pub async fn list_users(
311        &self,
312        limit: Option<usize>,
313        offset: Option<usize>,
314        active_only: bool,
315    ) -> Result<Vec<UserInfo>> {
316        let bytes = self.storage.get_kv("users:index").await?;
317        let user_ids: Vec<String> = match bytes {
318            Some(bytes) => serde_json::from_slice(&bytes)
319                .map_err(|e| AuthError::internal(format!("Failed to parse user index: {e}")))?,
320            None => return Ok(Vec::new()),
321        };
322
323        let skip = offset.unwrap_or(0);
324        let take = limit.unwrap_or(usize::MAX);
325        let mut users = Vec::new();
326
327        for user_id in user_ids.into_iter().skip(skip) {
328            let user = self.get_user_info(&user_id).await?;
329            if active_only && !user.active {
330                continue;
331            }
332            users.push(user);
333            if users.len() >= take {
334                break;
335            }
336        }
337
338        Ok(users)
339    }
340
341    /// Check if user exists.
342    ///
343    /// # Example
344    /// ```rust,ignore
345    /// if um.user_exists("user-1").await? {
346    ///     println!("user found");
347    /// }
348    /// ```
349    pub async fn user_exists(&self, user_id: &str) -> Result<bool> {
350        debug!("Checking if user '{}' exists", user_id);
351
352        if user_id.is_empty() {
353            return Ok(false);
354        }
355
356        let key = format!("user:{}", user_id);
357        Ok(self.storage.get_kv(&key).await?.is_some())
358    }
359
360    // ────────────────────────────────────────────────────────────────────────
361    // Full user lifecycle management (migrated from auth.rs::AuthFramework)
362    // ────────────────────────────────────────────────────────────────────────
363
364    /// Register a new user, creating all required storage records.
365    ///
366    /// # Example
367    /// ```rust,ignore
368    /// let uid = um.register_user("alice", "alice@example.com", "Str0ng!Pass").await?;
369    /// println!("registered user: {}", uid);
370    /// ```
371    pub async fn register_user(
372        &self,
373        username: &str,
374        email: &str,
375        password: &str,
376    ) -> Result<String> {
377        debug!("Registering new user: {}", username);
378
379        let username_key = format!("user:username:{}", username);
380        if self.storage.get_kv(&username_key).await?.is_some() {
381            return Err(AuthError::validation("Username already exists".to_string()));
382        }
383
384        let email_key = format!("user:email:{}", email);
385        if self.storage.get_kv(&email_key).await?.is_some() {
386            return Err(AuthError::validation("Email already exists".to_string()));
387        }
388
389        let user_id = crate::utils::string::generate_id(Some("user"));
390
391        let password_hash = bcrypt::hash(password, bcrypt::DEFAULT_COST)
392            .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
393
394        let user_data = serde_json::json!({
395            "user_id": user_id,
396            "username": username,
397            "email": email,
398            "password_hash": password_hash,
399            "roles": ["user"],
400            "active": true,
401            "email_verified": false,
402            "created_at": chrono::Utc::now().to_rfc3339(),
403        });
404
405        let user_key = format!("user:{}", user_id);
406        self.storage
407            .store_kv(&user_key, user_data.to_string().as_bytes(), None)
408            .await?;
409
410        self.storage
411            .store_kv(&username_key, user_id.as_bytes(), None)
412            .await?;
413        self.storage
414            .store_kv(&email_key, user_id.as_bytes(), None)
415            .await?;
416
417        // Maintain global user index for admin listing.
418        let index_key = "users:index";
419        let mut ids: Vec<String> = match self.storage.get_kv(index_key).await? {
420            Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
421            None => vec![],
422        };
423        ids.push(user_id.clone());
424        if let Ok(idx_json) = serde_json::to_vec(&ids) {
425            if let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await {
426                warn!("Failed to update user index during registration: {}", e);
427            }
428        }
429
430        // Store Argon2 credentials record for authenticate_password_builtin.
431        let creds_key = format!("user:credentials:{}", username);
432        let creds_hash = match crate::utils::password::hash_password_argon2id(password) {
433            Ok(h) => h,
434            Err(e) => {
435                warn!("Failed to hash credentials for user '{}': {}", username, e);
436                return Ok(user_id);
437            }
438        };
439        let creds_data = serde_json::json!({
440            "user_id": user_id,
441            "username": username,
442            "email": email,
443            "password_hash": creds_hash,
444            "created_at": chrono::Utc::now().to_rfc3339(),
445        });
446        if let Err(e) = self
447            .storage
448            .store_kv(&creds_key, creds_data.to_string().as_bytes(), None)
449            .await
450        {
451            warn!("Failed to store credentials for user '{}': {}", username, e);
452        }
453
454        info!("User '{}' registered successfully", username);
455        Ok(user_id)
456    }
457
458    /// Delete a user and all associated storage records.
459    ///
460    /// # Example
461    /// ```rust,ignore
462    /// um.delete_user("alice").await?;
463    /// ```
464    pub async fn delete_user(&self, username: &str) -> Result<()> {
465        debug!("Deleting user: {}", username);
466
467        let username_key = format!("user:username:{}", username);
468        let user_id_data = self
469            .storage
470            .get_kv(&username_key)
471            .await?
472            .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
473
474        let user_id = String::from_utf8(user_id_data)
475            .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
476
477        // Remove email reverse-lookup.
478        let user_key = format!("user:{}", user_id);
479        if let Some(user_data_bytes) = self.storage.get_kv(&user_key).await?
480            && let Ok(user_json_str) = String::from_utf8(user_data_bytes)
481            && let Ok(user_data) = serde_json::from_str::<serde_json::Value>(&user_json_str)
482            && let Some(email) = user_data.get("email").and_then(|v| v.as_str())
483        {
484            if let Err(e) = self
485                .storage
486                .delete_kv(&format!("user:email:{}", email))
487                .await
488            {
489                warn!(
490                    "Failed to delete email index for user '{}': {}",
491                    username, e
492                );
493            }
494        }
495
496        // Remove from global index.
497        let index_key = "users:index";
498        if let Ok(Some(bytes)) = self.storage.get_kv(index_key).await {
499            let mut ids: Vec<String> = serde_json::from_slice(&bytes).unwrap_or_default();
500            ids.retain(|id| id != &user_id);
501            if let Ok(idx_json) = serde_json::to_vec(&ids) {
502                if let Err(e) = self.storage.store_kv(index_key, &idx_json, None).await {
503                    warn!(
504                        "Failed to update user index during deletion of '{}': {}",
505                        username, e
506                    );
507                }
508            }
509        }
510
511        if let Err(e) = self.storage.delete_kv(&user_key).await {
512            warn!("Failed to delete user record for '{}': {}", username, e);
513        }
514        if let Err(e) = self.storage.delete_kv(&username_key).await {
515            warn!("Failed to delete username index for '{}': {}", username, e);
516        }
517        if let Err(e) = self
518            .storage
519            .delete_kv(&format!("user:credentials:{}", username))
520            .await
521        {
522            warn!("Failed to delete credentials for '{}': {}", username, e);
523        }
524        if let Err(e) = self
525            .storage
526            .delete_kv(&format!("user:{}:totp_secret", user_id))
527            .await
528        {
529            warn!("Failed to delete TOTP secret for '{}': {}", username, e);
530        }
531        if let Err(e) = self
532            .storage
533            .delete_kv(&format!("user:{}:backup_codes", user_id))
534            .await
535        {
536            warn!("Failed to delete backup codes for '{}': {}", username, e);
537        }
538
539        info!("User '{}' deleted successfully", username);
540        Ok(())
541    }
542
543    /// Delete a user by canonical user ID.
544    ///
545    /// # Example
546    /// ```rust,ignore
547    /// um.delete_user_by_id("user-1").await?;
548    /// ```
549    pub async fn delete_user_by_id(&self, user_id: &str) -> Result<()> {
550        let username = self.get_username_by_id(user_id).await?;
551        self.delete_user(&username).await
552    }
553
554    /// Update the roles assigned to a user.
555    ///
556    /// # Example
557    /// ```rust,ignore
558    /// um.update_user_roles("user-1", &["admin".into(), "editor".into()]).await?;
559    /// ```
560    pub async fn update_user_roles(&self, user_id: &str, roles: &[String]) -> Result<()> {
561        let user_key = format!("user:{}", user_id);
562        let bytes = self
563            .storage
564            .get_kv(&user_key)
565            .await?
566            .ok_or(AuthError::UserNotFound)?;
567        let mut user_data: serde_json::Value =
568            serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
569        user_data["roles"] = serde_json::json!(roles);
570        user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
571        self.storage
572            .store_kv(&user_key, user_data.to_string().as_bytes(), None)
573            .await?;
574        info!("Roles updated for user '{}'", user_id);
575        Ok(())
576    }
577
578    /// Enable or disable a user account.
579    ///
580    /// # Example
581    /// ```rust,ignore
582    /// um.set_user_active("user-1", false).await?; // disable
583    /// ```
584    pub async fn set_user_active(&self, user_id: &str, active: bool) -> Result<()> {
585        let user_key = format!("user:{}", user_id);
586        let bytes = self
587            .storage
588            .get_kv(&user_key)
589            .await?
590            .ok_or(AuthError::UserNotFound)?;
591        let mut user_data: serde_json::Value =
592            serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
593        user_data["active"] = serde_json::json!(active);
594        user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
595        self.storage
596            .store_kv(&user_key, user_data.to_string().as_bytes(), None)
597            .await?;
598        info!("User '{}' active status set to {}", user_id, active);
599        Ok(())
600    }
601
602    /// Update the email address stored on a user.
603    ///
604    /// # Example
605    /// ```rust,ignore
606    /// um.update_user_email("user-1", "new@example.com").await?;
607    /// ```
608    pub async fn update_user_email(&self, user_id: &str, email: &str) -> Result<()> {
609        let user_key = format!("user:{}", user_id);
610        let bytes = self
611            .storage
612            .get_kv(&user_key)
613            .await?
614            .ok_or(AuthError::UserNotFound)?;
615        let mut user_data: serde_json::Value =
616            serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
617
618        let new_email_key = format!("user:email:{}", email);
619        if let Some(existing_user_id) = self.storage.get_kv(&new_email_key).await? {
620            let existing_user_id = String::from_utf8(existing_user_id)
621                .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {e}")))?;
622            if existing_user_id != user_id {
623                return Err(AuthError::validation("Email already exists".to_string()));
624            }
625        }
626
627        if let Some(old_email) = user_data.get("email").and_then(|value| value.as_str())
628            && old_email != email
629        {
630            self.storage
631                .delete_kv(&format!("user:email:{}", old_email))
632                .await?;
633        }
634
635        user_data["email"] = serde_json::json!(email);
636        user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
637
638        self.storage
639            .store_kv(&user_key, user_data.to_string().as_bytes(), None)
640            .await?;
641        self.storage
642            .store_kv(&new_email_key, user_id.as_bytes(), None)
643            .await?;
644
645        Ok(())
646    }
647
648    /// Verify a user's password against the stored bcrypt hash.
649    ///
650    /// # Example
651    /// ```rust,ignore
652    /// let ok = um.verify_user_password("user-1", "secret").await?;
653    /// assert!(ok);
654    /// ```
655    pub async fn verify_user_password(&self, user_id: &str, password: &str) -> Result<bool> {
656        let user_key = format!("user:{}", user_id);
657        let bytes = self
658            .storage
659            .get_kv(&user_key)
660            .await?
661            .ok_or(AuthError::UserNotFound)?;
662        let user_data: serde_json::Value =
663            serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
664        let hash = user_data["password_hash"]
665            .as_str()
666            .ok_or_else(|| AuthError::internal("User has no password hash".to_string()))?;
667        bcrypt::verify(password, hash)
668            .map_err(|e| AuthError::crypto(format!("Password verification failed: {}", e)))
669    }
670
671    /// Resolve a user_id to its username.
672    ///
673    /// # Example
674    /// ```rust,ignore
675    /// let name = um.get_username_by_id("user-1").await?;
676    /// ```
677    pub async fn get_username_by_id(&self, user_id: &str) -> Result<String> {
678        let user_key = format!("user:{}", user_id);
679        let bytes = self
680            .storage
681            .get_kv(&user_key)
682            .await?
683            .ok_or(AuthError::UserNotFound)?;
684        let user_data: serde_json::Value =
685            serde_json::from_slice(&bytes).map_err(|e| AuthError::crypto(format!("{e}")))?;
686        user_data["username"]
687            .as_str()
688            .map(|s| s.to_string())
689            .ok_or_else(|| AuthError::internal("User has no username field".to_string()))
690    }
691
692    /// Check whether a username is already taken.
693    ///
694    /// # Example
695    /// ```rust,ignore
696    /// if um.username_exists("alice").await? {
697    ///     println!("taken");
698    /// }
699    /// ```
700    pub async fn username_exists(&self, username: &str) -> Result<bool> {
701        Ok(self
702            .storage
703            .get_kv(&format!("user:username:{}", username))
704            .await?
705            .is_some())
706    }
707
708    /// Check whether an email address is already registered.
709    ///
710    /// # Example
711    /// ```rust,ignore
712    /// if um.email_exists("a@b.com").await? {
713    ///     println!("already registered");
714    /// }
715    /// ```
716    pub async fn email_exists(&self, email: &str) -> Result<bool> {
717        Ok(self
718            .storage
719            .get_kv(&format!("user:email:{}", email))
720            .await?
721            .is_some())
722    }
723
724    /// Fetch raw user data by username.
725    ///
726    /// # Example
727    /// ```rust,ignore
728    /// let data = um.get_user_by_username("alice").await?;
729    /// println!("email: {:?}", data.get("email"));
730    /// ```
731    pub async fn get_user_by_username(
732        &self,
733        username: &str,
734    ) -> Result<HashMap<String, serde_json::Value>> {
735        let username_key = format!("user:username:{}", username);
736        let user_id_data = self
737            .storage
738            .get_kv(&username_key)
739            .await?
740            .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
741        let user_id = String::from_utf8(user_id_data)
742            .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
743        let user_key = format!("user:{}", user_id);
744        let user_data = self
745            .storage
746            .get_kv(&user_key)
747            .await?
748            .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
749        let user_obj: serde_json::Value = serde_json::from_slice(&user_data)
750            .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
751        if let Some(obj) = user_obj.as_object() {
752            Ok(obj
753                .into_iter()
754                .map(|(k, v)| (k.clone(), v.clone()))
755                .collect())
756        } else {
757            Err(AuthError::validation(
758                "Invalid user data structure".to_string(),
759            ))
760        }
761    }
762
763    /// Get a sanitised user profile (no password hash) for display/API.
764    ///
765    /// # Example
766    /// ```rust,ignore
767    /// let profile = um.get_user_profile("user-1").await?;
768    /// println!("email: {:?}", profile.email);
769    /// ```
770    pub async fn get_user_profile(
771        &self,
772        user_id: &str,
773    ) -> Result<crate::providers::ProviderProfile> {
774        let user_key = format!("user:{}", user_id);
775        if let Ok(Some(bytes)) = self.storage.get_kv(&user_key).await
776            && let Ok(user_data) = serde_json::from_slice::<serde_json::Value>(&bytes)
777        {
778            let username = user_data["username"].as_str().map(|s| s.to_string());
779            let email = user_data["email"].as_str().map(|s| s.to_string());
780            let name = user_data["name"].as_str().map(|s| s.to_string());
781            let email_verified = user_data["email_verified"].as_bool();
782
783            let mut additional_data = std::collections::HashMap::new();
784            if let Some(obj) = user_data.as_object() {
785                for (k, v) in obj {
786                    match k.as_str() {
787                        "user_id" | "username" | "email" | "name" | "email_verified"
788                        | "password_hash" | "created_at" | "updated_at" => {}
789                        _ => {
790                            additional_data.insert(k.clone(), v.clone());
791                        }
792                    }
793                }
794            }
795
796            return Ok(crate::providers::ProviderProfile {
797                id: Some(user_id.to_string()),
798                provider: Some("local".to_string()),
799                username,
800                name,
801                email,
802                email_verified,
803                picture: None,
804                locale: None,
805                additional_data,
806            });
807        }
808        Err(AuthError::UserNotFound)
809    }
810
811    /// Get a user's roles/scopes from storage, returning `["user"]` as fallback.
812    ///
813    /// # Example
814    /// ```rust,ignore
815    /// let roles = um.get_user_roles("user-1").await?;
816    /// assert!(roles.contains(&"user".to_string()));
817    /// ```
818    pub async fn get_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
819        let user_key = format!("user:{}", user_id);
820        if let Ok(Some(data)) = self.storage.get_kv(&user_key).await
821            && let Ok(v) = serde_json::from_slice::<serde_json::Value>(&data)
822            && let Some(arr) = v.get("roles").and_then(|r| r.as_array())
823        {
824            let roles: Vec<String> = arr
825                .iter()
826                .filter_map(|v| v.as_str().map(String::from))
827                .collect();
828            if !roles.is_empty() {
829                return Ok(roles);
830            }
831        }
832        Ok(vec!["user".to_string()])
833    }
834
835    /// Verify username/password credentials in a timing-safe manner.
836    ///
837    /// Returns `Ok(None)` when the credentials are invalid — a dummy Argon2
838    /// verification is always executed when the username is not found, so
839    /// callers cannot distinguish missing users from wrong passwords via timing.
840    /// Returns `Ok(Some(result))` on success.
841    ///
842    /// # Example
843    /// ```rust,ignore
844    /// match um.verify_login_credentials("alice", "password123").await? {
845    ///     Some(cred) => println!("user_id={}, mfa={}", cred.user_id, cred.mfa_enabled),
846    ///     None => println!("invalid credentials"),
847    /// }
848    /// ```
849    pub async fn verify_login_credentials(
850        &self,
851        username: &str,
852        password: &str,
853    ) -> Result<Option<CredentialCheckResult>> {
854        use crate::utils::password::verify_password_argon2id;
855
856        if username.is_empty() || password.is_empty() {
857            return Ok(None);
858        }
859
860        let user_key = format!("user:credentials:{username}");
861        let stored_bytes = match self.storage.get_kv(&user_key).await? {
862            Some(bytes) => bytes,
863            None => {
864                // Constant-time: always do real work even for missing users.
865                let _ = verify_password_argon2id(
866                    password,
867                    "$argon2id$v=19$m=19456,t=2,p=1$dGVzdHNhbHRmb3J0aW1pbmc$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
868                );
869                return Ok(None);
870            }
871        };
872
873        let user_data_str = String::from_utf8(stored_bytes)
874            .map_err(|e| AuthError::internal(format!("Failed to parse user data: {e}")))?;
875        let user_data: serde_json::Value = serde_json::from_str(&user_data_str)
876            .map_err(|e| AuthError::internal(format!("Failed to parse user JSON: {e}")))?;
877
878        let password_hash = user_data["password_hash"].as_str().ok_or_else(|| {
879            AuthError::internal("Missing password hash in user record".to_string())
880        })?;
881
882        if !verify_password_argon2id(password, password_hash).unwrap_or(false) {
883            return Ok(None);
884        }
885
886        let user_id = user_data["user_id"]
887            .as_str()
888            .ok_or_else(|| AuthError::internal("Missing user_id in user record".to_string()))?
889            .to_string();
890
891        // Check whether the account has been deactivated.
892        let canonical_key = format!("user:{}", user_id);
893        if let Ok(Some(canonical_bytes)) = self.storage.get_kv(&canonical_key).await
894            && let Ok(canonical_str) = String::from_utf8(canonical_bytes)
895            && let Ok(canonical_data) = serde_json::from_str::<serde_json::Value>(&canonical_str)
896            && !canonical_data["active"].as_bool().unwrap_or(true)
897        {
898            return Ok(None);
899        }
900
901        let mfa_enabled = matches!(
902            self.storage
903                .get_kv(&format!("mfa_enabled:{}", user_id))
904                .await,
905            Ok(Some(_))
906        );
907
908        Ok(Some(CredentialCheckResult {
909            user_id,
910            mfa_enabled,
911        }))
912    }
913
914    /// Update a user's password by username.
915    ///
916    /// # Example
917    /// ```rust,ignore
918    /// um.update_user_password("alice", "N3wStr0ng!Pass").await?;
919    /// ```
920    pub async fn update_user_password(&self, username: &str, new_password: &str) -> Result<()> {
921        debug!("Updating password for user: {}", username);
922
923        crate::utils::validation::validate_password(new_password)
924            .map_err(|e| AuthError::validation(format!("Password validation failed: {e}")))?;
925
926        let username_key = format!("user:username:{}", username);
927        let user_id_data = self
928            .storage
929            .get_kv(&username_key)
930            .await?
931            .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
932        let user_id = String::from_utf8(user_id_data)
933            .map_err(|e| AuthError::crypto(format!("Invalid user ID format: {}", e)))?;
934
935        let user_key = format!("user:{}", user_id);
936        let user_bytes = self
937            .storage
938            .get_kv(&user_key)
939            .await?
940            .ok_or_else(|| AuthError::validation("User not found".to_string()))?;
941        let mut user_data: serde_json::Value = serde_json::from_slice(&user_bytes)
942            .map_err(|e| AuthError::crypto(format!("Failed to parse user data: {}", e)))?;
943
944        let password_hash = bcrypt::hash(new_password, bcrypt::DEFAULT_COST)
945            .map_err(|e| AuthError::crypto(format!("Failed to hash password: {}", e)))?;
946        user_data["password_hash"] = serde_json::json!(password_hash);
947        user_data["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
948        self.storage
949            .store_kv(&user_key, user_data.to_string().as_bytes(), None)
950            .await?;
951
952        // Update Argon2 credentials record used by the login endpoint.
953        let creds_key = format!("user:credentials:{}", username);
954        let creds_hash = crate::utils::password::hash_password_argon2id(new_password)
955            .map_err(|e| AuthError::crypto(format!("Failed to hash login credentials: {e}")))?;
956        let creds_bytes =
957            self.storage.get_kv(&creds_key).await?.ok_or_else(|| {
958                AuthError::internal("Login credentials record not found".to_string())
959            })?;
960        let mut creds: serde_json::Value = serde_json::from_slice(&creds_bytes)
961            .map_err(|e| AuthError::internal(format!("Failed to parse credentials record: {e}")))?;
962        creds["password_hash"] = serde_json::json!(creds_hash);
963        creds["updated_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
964        self.storage
965            .store_kv(&creds_key, creds.to_string().as_bytes(), None)
966            .await?;
967
968        info!("Password updated for user: {}", username);
969        Ok(())
970    }
971
972    /// Update a user password by canonical user ID.
973    ///
974    /// # Example
975    /// ```rust,ignore
976    /// um.update_user_password_by_id("user-1", "N3wStr0ng!Pass").await?;
977    /// ```
978    pub async fn update_user_password_by_id(
979        &self,
980        user_id: &str,
981        new_password: &str,
982    ) -> Result<()> {
983        let username = self.get_username_by_id(user_id).await?;
984        self.update_user_password(&username, new_password).await
985    }
986}
987
988#[cfg(test)]
989mod tests {
990    use super::*;
991    use crate::storage::MemoryStorage;
992
993    fn make_manager() -> UserManager {
994        UserManager::new(Arc::new(MemoryStorage::new()))
995    }
996
997    // ── register_user ───────────────────────────────────────────────────
998
999    #[tokio::test]
1000    async fn test_register_user_success() {
1001        let mgr = make_manager();
1002        let id = mgr
1003            .register_user("alice", "alice@example.com", "StrongP@ss1!")
1004            .await
1005            .unwrap();
1006        assert!(id.starts_with("user"));
1007    }
1008
1009    #[tokio::test]
1010    async fn test_register_user_duplicate_username() {
1011        let mgr = make_manager();
1012        mgr.register_user("bob", "bob@example.com", "StrongP@ss1!")
1013            .await
1014            .unwrap();
1015        let err = mgr
1016            .register_user("bob", "bob2@example.com", "StrongP@ss1!")
1017            .await;
1018        assert!(err.is_err());
1019    }
1020
1021    #[tokio::test]
1022    async fn test_register_user_duplicate_email() {
1023        let mgr = make_manager();
1024        mgr.register_user("carol", "dup@example.com", "StrongP@ss1!")
1025            .await
1026            .unwrap();
1027        let err = mgr
1028            .register_user("carol2", "dup@example.com", "StrongP@ss1!")
1029            .await;
1030        assert!(err.is_err());
1031    }
1032
1033    // ── get_user_info ───────────────────────────────────────────────────
1034
1035    #[tokio::test]
1036    async fn test_get_user_info_success() {
1037        let mgr = make_manager();
1038        let id = mgr
1039            .register_user("dave", "dave@example.com", "StrongP@ss1!")
1040            .await
1041            .unwrap();
1042        let info = mgr.get_user_info(&id).await.unwrap();
1043        assert_eq!(info.username, "dave");
1044        assert!(info.active);
1045    }
1046
1047    #[tokio::test]
1048    async fn test_get_user_info_not_found() {
1049        let mgr = make_manager();
1050        assert!(mgr.get_user_info("nonexistent").await.is_err());
1051    }
1052
1053    // ── user_exists ─────────────────────────────────────────────────────
1054
1055    #[tokio::test]
1056    async fn test_user_exists_true() {
1057        let mgr = make_manager();
1058        let id = mgr
1059            .register_user("eve", "eve@example.com", "StrongP@ss1!")
1060            .await
1061            .unwrap();
1062        assert!(mgr.user_exists(&id).await.unwrap());
1063    }
1064
1065    #[tokio::test]
1066    async fn test_user_exists_false() {
1067        let mgr = make_manager();
1068        assert!(!mgr.user_exists("nobody").await.unwrap());
1069    }
1070
1071    #[tokio::test]
1072    async fn test_user_exists_empty_id() {
1073        let mgr = make_manager();
1074        assert!(!mgr.user_exists("").await.unwrap());
1075    }
1076
1077    // ── delete_user ─────────────────────────────────────────────────────
1078
1079    #[tokio::test]
1080    async fn test_delete_user_success() {
1081        let mgr = make_manager();
1082        let id = mgr
1083            .register_user("frank", "frank@example.com", "StrongP@ss1!")
1084            .await
1085            .unwrap();
1086        mgr.delete_user("frank").await.unwrap();
1087        assert!(!mgr.user_exists(&id).await.unwrap());
1088    }
1089
1090    #[tokio::test]
1091    async fn test_delete_user_not_found() {
1092        let mgr = make_manager();
1093        assert!(mgr.delete_user("ghost").await.is_err());
1094    }
1095
1096    #[tokio::test]
1097    async fn test_delete_user_by_id() {
1098        let mgr = make_manager();
1099        let id = mgr
1100            .register_user("gina", "gina@example.com", "StrongP@ss1!")
1101            .await
1102            .unwrap();
1103        mgr.delete_user_by_id(&id).await.unwrap();
1104        assert!(!mgr.user_exists(&id).await.unwrap());
1105    }
1106
1107    // ── list_users ──────────────────────────────────────────────────────
1108
1109    #[tokio::test]
1110    async fn test_list_users_empty() {
1111        let mgr = make_manager();
1112        let users = mgr.list_users(None, None, false).await.unwrap();
1113        assert!(users.is_empty());
1114    }
1115
1116    #[tokio::test]
1117    async fn test_list_users_with_limit_and_offset() {
1118        let mgr = make_manager();
1119        mgr.register_user("u1", "u1@example.com", "StrongP@ss1!")
1120            .await
1121            .unwrap();
1122        mgr.register_user("u2", "u2@example.com", "StrongP@ss1!")
1123            .await
1124            .unwrap();
1125        mgr.register_user("u3", "u3@example.com", "StrongP@ss1!")
1126            .await
1127            .unwrap();
1128        let page = mgr.list_users(Some(1), Some(1), false).await.unwrap();
1129        assert_eq!(page.len(), 1);
1130    }
1131
1132    // ── verify_user_password ────────────────────────────────────────────
1133
1134    #[tokio::test]
1135    async fn test_verify_password_correct() {
1136        let mgr = make_manager();
1137        let id = mgr
1138            .register_user("hank", "hank@example.com", "StrongP@ss1!")
1139            .await
1140            .unwrap();
1141        assert!(mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1142    }
1143
1144    #[tokio::test]
1145    async fn test_verify_password_incorrect() {
1146        let mgr = make_manager();
1147        let id = mgr
1148            .register_user("ivan", "ivan@example.com", "StrongP@ss1!")
1149            .await
1150            .unwrap();
1151        assert!(!mgr.verify_user_password(&id, "wrong").await.unwrap());
1152    }
1153
1154    #[tokio::test]
1155    async fn test_verify_password_user_not_found() {
1156        let mgr = make_manager();
1157        assert!(mgr.verify_user_password("ghost", "x").await.is_err());
1158    }
1159
1160    // ── update_user_password ────────────────────────────────────────────
1161
1162    #[tokio::test]
1163    async fn test_update_password() {
1164        let mgr = make_manager();
1165        let id = mgr
1166            .register_user("jack", "jack@example.com", "StrongP@ss1!")
1167            .await
1168            .unwrap();
1169        mgr.update_user_password("jack", "NewStr0ng!Pass")
1170            .await
1171            .unwrap();
1172        assert!(
1173            mgr.verify_user_password(&id, "NewStr0ng!Pass")
1174                .await
1175                .unwrap()
1176        );
1177        assert!(!mgr.verify_user_password(&id, "StrongP@ss1!").await.unwrap());
1178    }
1179
1180    #[tokio::test]
1181    async fn test_update_password_user_not_found() {
1182        let mgr = make_manager();
1183        assert!(
1184            mgr.update_user_password("ghost", "NewStr0ng!Pass")
1185                .await
1186                .is_err()
1187        );
1188    }
1189
1190    // ── update_user_roles ───────────────────────────────────────────────
1191
1192    #[tokio::test]
1193    async fn test_update_user_roles() {
1194        let mgr = make_manager();
1195        let id = mgr
1196            .register_user("kate", "kate@example.com", "StrongP@ss1!")
1197            .await
1198            .unwrap();
1199        mgr.update_user_roles(&id, &["admin".into(), "user".into()])
1200            .await
1201            .unwrap();
1202        let info = mgr.get_user_info(&id).await.unwrap();
1203        assert!(info.roles.contains(&"admin".to_string()));
1204    }
1205
1206    #[tokio::test]
1207    async fn test_update_user_roles_not_found() {
1208        let mgr = make_manager();
1209        assert!(
1210            mgr.update_user_roles("ghost", &["admin".into()])
1211                .await
1212                .is_err()
1213        );
1214    }
1215
1216    // ── set_user_active ─────────────────────────────────────────────────
1217
1218    #[tokio::test]
1219    async fn test_set_user_active_disable() {
1220        let mgr = make_manager();
1221        let id = mgr
1222            .register_user("leon", "leon@example.com", "StrongP@ss1!")
1223            .await
1224            .unwrap();
1225        mgr.set_user_active(&id, false).await.unwrap();
1226        let info = mgr.get_user_info(&id).await.unwrap();
1227        assert!(!info.active);
1228    }
1229
1230    #[tokio::test]
1231    async fn test_set_user_active_not_found() {
1232        let mgr = make_manager();
1233        assert!(mgr.set_user_active("ghost", false).await.is_err());
1234    }
1235
1236    // ── update_user_email ───────────────────────────────────────────────
1237
1238    #[tokio::test]
1239    async fn test_update_user_email() {
1240        let mgr = make_manager();
1241        let id = mgr
1242            .register_user("mary", "mary@example.com", "StrongP@ss1!")
1243            .await
1244            .unwrap();
1245        mgr.update_user_email(&id, "mary_new@example.com")
1246            .await
1247            .unwrap();
1248        let info = mgr.get_user_info(&id).await.unwrap();
1249        assert_eq!(info.email.as_deref(), Some("mary_new@example.com"));
1250    }
1251
1252    #[tokio::test]
1253    async fn test_update_user_email_already_taken() {
1254        let mgr = make_manager();
1255        mgr.register_user("n1", "taken@example.com", "StrongP@ss1!")
1256            .await
1257            .unwrap();
1258        let id2 = mgr
1259            .register_user("n2", "n2@example.com", "StrongP@ss1!")
1260            .await
1261            .unwrap();
1262        assert!(
1263            mgr.update_user_email(&id2, "taken@example.com")
1264                .await
1265                .is_err()
1266        );
1267    }
1268
1269    // ── API key operations ──────────────────────────────────────────────
1270
1271    #[tokio::test]
1272    async fn test_create_and_validate_api_key() {
1273        let mgr = make_manager();
1274        let id = mgr
1275            .register_user("oscar", "oscar@example.com", "StrongP@ss1!")
1276            .await
1277            .unwrap();
1278        let key = mgr.create_api_key(&id, None).await.unwrap();
1279        assert!(key.starts_with("ak_"));
1280        let info = mgr.validate_api_key(&key).await.unwrap();
1281        assert_eq!(info.id, id);
1282    }
1283
1284    #[tokio::test]
1285    async fn test_validate_api_key_invalid() {
1286        let mgr = make_manager();
1287        assert!(mgr.validate_api_key("bad_key").await.is_err());
1288    }
1289
1290    #[tokio::test]
1291    async fn test_revoke_api_key() {
1292        let mgr = make_manager();
1293        let id = mgr
1294            .register_user("pat", "pat@example.com", "StrongP@ss1!")
1295            .await
1296            .unwrap();
1297        let key = mgr.create_api_key(&id, None).await.unwrap();
1298        mgr.revoke_api_key(&key).await.unwrap();
1299        assert!(mgr.validate_api_key(&key).await.is_err());
1300    }
1301
1302    #[tokio::test]
1303    async fn test_revoke_api_key_not_found() {
1304        let mgr = make_manager();
1305        assert!(mgr.revoke_api_key("nonexistent").await.is_err());
1306    }
1307
1308    // ── validate_username ───────────────────────────────────────────────
1309
1310    #[tokio::test]
1311    async fn test_validate_username_valid() {
1312        let mgr = make_manager();
1313        assert!(mgr.validate_username("good_user-1").await.unwrap());
1314    }
1315
1316    #[tokio::test]
1317    async fn test_validate_username_too_short() {
1318        let mgr = make_manager();
1319        assert!(!mgr.validate_username("ab").await.unwrap());
1320    }
1321
1322    #[tokio::test]
1323    async fn test_validate_username_special_chars() {
1324        let mgr = make_manager();
1325        assert!(!mgr.validate_username("user@name").await.unwrap());
1326    }
1327
1328    // ── validate_display_name ───────────────────────────────────────────
1329
1330    #[tokio::test]
1331    async fn test_validate_display_name_valid() {
1332        let mgr = make_manager();
1333        assert!(mgr.validate_display_name("Alice Bob").await.unwrap());
1334    }
1335
1336    #[tokio::test]
1337    async fn test_validate_display_name_empty() {
1338        let mgr = make_manager();
1339        assert!(!mgr.validate_display_name("").await.unwrap());
1340    }
1341
1342    #[tokio::test]
1343    async fn test_validate_display_name_only_whitespace() {
1344        let mgr = make_manager();
1345        assert!(!mgr.validate_display_name("   ").await.unwrap());
1346    }
1347
1348    // ── validate_password_strength ──────────────────────────────────────
1349
1350    #[tokio::test]
1351    async fn test_validate_password_strong() {
1352        let mgr = make_manager();
1353        assert!(
1354            mgr.validate_password_strength("C0mpl3x!P@ssw0rd")
1355                .await
1356                .unwrap()
1357        );
1358    }
1359
1360    #[tokio::test]
1361    async fn test_validate_password_weak() {
1362        let mgr = make_manager();
1363        assert!(!mgr.validate_password_strength("123").await.unwrap());
1364    }
1365
1366    // ── validate_user_input ─────────────────────────────────────────────
1367
1368    #[tokio::test]
1369    async fn test_validate_user_input_clean() {
1370        let mgr = make_manager();
1371        assert!(mgr.validate_user_input("Hello World 123").await.unwrap());
1372    }
1373
1374    #[tokio::test]
1375    async fn test_validate_user_input_html_tags() {
1376        let mgr = make_manager();
1377        assert!(
1378            !mgr.validate_user_input("<script>alert(1)</script>")
1379                .await
1380                .unwrap()
1381        );
1382    }
1383
1384    #[tokio::test]
1385    async fn test_validate_user_input_sql_injection() {
1386        let mgr = make_manager();
1387        assert!(
1388            !mgr.validate_user_input("'; drop table users--")
1389                .await
1390                .unwrap()
1391        );
1392    }
1393
1394    #[tokio::test]
1395    async fn test_validate_user_input_template_injection() {
1396        let mgr = make_manager();
1397        assert!(!mgr.validate_user_input("${evil}").await.unwrap());
1398    }
1399
1400    #[tokio::test]
1401    async fn test_validate_user_input_path_traversal() {
1402        let mgr = make_manager();
1403        assert!(!mgr.validate_user_input("../../etc/passwd").await.unwrap());
1404    }
1405
1406    #[tokio::test]
1407    async fn test_validate_user_input_javascript_uri() {
1408        let mgr = make_manager();
1409        assert!(
1410            !mgr.validate_user_input("javascript:alert(1)")
1411                .await
1412                .unwrap()
1413        );
1414    }
1415
1416    #[tokio::test]
1417    async fn test_validate_user_input_empty() {
1418        let mgr = make_manager();
1419        assert!(!mgr.validate_user_input("").await.unwrap());
1420    }
1421
1422    #[tokio::test]
1423    async fn test_validate_user_input_encoded_tags() {
1424        let mgr = make_manager();
1425        assert!(!mgr.validate_user_input("%3cscript%3e").await.unwrap());
1426    }
1427
1428    // ── username_exists / email_exists ───────────────────────────────────
1429
1430    #[tokio::test]
1431    async fn test_username_exists() {
1432        let mgr = make_manager();
1433        mgr.register_user("quinn", "quinn@example.com", "StrongP@ss1!")
1434            .await
1435            .unwrap();
1436        assert!(mgr.username_exists("quinn").await.unwrap());
1437        assert!(!mgr.username_exists("noone").await.unwrap());
1438    }
1439
1440    #[tokio::test]
1441    async fn test_email_exists() {
1442        let mgr = make_manager();
1443        mgr.register_user("ross", "ross@example.com", "StrongP@ss1!")
1444            .await
1445            .unwrap();
1446        assert!(mgr.email_exists("ross@example.com").await.unwrap());
1447        assert!(!mgr.email_exists("nobody@example.com").await.unwrap());
1448    }
1449
1450    // ── get_user_by_username ────────────────────────────────────────────
1451
1452    #[tokio::test]
1453    async fn test_get_user_by_username() {
1454        let mgr = make_manager();
1455        mgr.register_user("sam", "sam@example.com", "StrongP@ss1!")
1456            .await
1457            .unwrap();
1458        let data = mgr.get_user_by_username("sam").await.unwrap();
1459        assert_eq!(data["username"].as_str(), Some("sam"));
1460    }
1461
1462    #[tokio::test]
1463    async fn test_get_user_by_username_not_found() {
1464        let mgr = make_manager();
1465        assert!(mgr.get_user_by_username("ghost").await.is_err());
1466    }
1467
1468    // ── get_user_profile ────────────────────────────────────────────────
1469
1470    #[tokio::test]
1471    async fn test_get_user_profile() {
1472        let mgr = make_manager();
1473        let id = mgr
1474            .register_user("tina", "tina@example.com", "StrongP@ss1!")
1475            .await
1476            .unwrap();
1477        let profile = mgr.get_user_profile(&id).await.unwrap();
1478        assert_eq!(profile.username.as_deref(), Some("tina"));
1479        assert_eq!(profile.email.as_deref(), Some("tina@example.com"));
1480        // password_hash should NOT be in additional_data
1481        assert!(!profile.additional_data.contains_key("password_hash"));
1482    }
1483
1484    #[tokio::test]
1485    async fn test_get_user_profile_not_found() {
1486        let mgr = make_manager();
1487        assert!(mgr.get_user_profile("ghost").await.is_err());
1488    }
1489
1490    // ── get_user_roles ──────────────────────────────────────────────────
1491
1492    #[tokio::test]
1493    async fn test_get_user_roles_default() {
1494        let mgr = make_manager();
1495        let id = mgr
1496            .register_user("uma", "uma@example.com", "StrongP@ss1!")
1497            .await
1498            .unwrap();
1499        let roles = mgr.get_user_roles(&id).await.unwrap();
1500        assert!(roles.contains(&"user".to_string()));
1501    }
1502
1503    #[tokio::test]
1504    async fn test_get_user_roles_not_found_returns_default() {
1505        let mgr = make_manager();
1506        let roles = mgr.get_user_roles("ghost").await.unwrap();
1507        assert_eq!(roles, vec!["user".to_string()]);
1508    }
1509
1510    // ── verify_login_credentials ────────────────────────────────────────
1511
1512    #[tokio::test]
1513    async fn test_verify_login_credentials_success() {
1514        let mgr = make_manager();
1515        mgr.register_user("vera", "vera@example.com", "StrongP@ss1!")
1516            .await
1517            .unwrap();
1518        let result = mgr
1519            .verify_login_credentials("vera", "StrongP@ss1!")
1520            .await
1521            .unwrap();
1522        assert!(result.is_some());
1523        assert!(!result.unwrap().mfa_enabled);
1524    }
1525
1526    #[tokio::test]
1527    async fn test_verify_login_credentials_wrong_password() {
1528        let mgr = make_manager();
1529        mgr.register_user("wanda", "wanda@example.com", "StrongP@ss1!")
1530            .await
1531            .unwrap();
1532        let result = mgr
1533            .verify_login_credentials("wanda", "wrong")
1534            .await
1535            .unwrap();
1536        assert!(result.is_none());
1537    }
1538
1539    #[tokio::test]
1540    async fn test_verify_login_credentials_unknown_user() {
1541        let mgr = make_manager();
1542        let result = mgr
1543            .verify_login_credentials("ghost", "StrongP@ss1!")
1544            .await
1545            .unwrap();
1546        assert!(result.is_none());
1547    }
1548
1549    #[tokio::test]
1550    async fn test_verify_login_credentials_empty_inputs() {
1551        let mgr = make_manager();
1552        assert!(
1553            mgr.verify_login_credentials("", "pass")
1554                .await
1555                .unwrap()
1556                .is_none()
1557        );
1558        assert!(
1559            mgr.verify_login_credentials("user", "")
1560                .await
1561                .unwrap()
1562                .is_none()
1563        );
1564    }
1565
1566    #[tokio::test]
1567    async fn test_verify_login_credentials_deactivated() {
1568        let mgr = make_manager();
1569        let id = mgr
1570            .register_user("xena", "xena@example.com", "StrongP@ss1!")
1571            .await
1572            .unwrap();
1573        mgr.set_user_active(&id, false).await.unwrap();
1574        let result = mgr
1575            .verify_login_credentials("xena", "StrongP@ss1!")
1576            .await
1577            .unwrap();
1578        assert!(result.is_none());
1579    }
1580
1581    // ── get_username_by_id ──────────────────────────────────────────────
1582
1583    #[tokio::test]
1584    async fn test_get_username_by_id() {
1585        let mgr = make_manager();
1586        let id = mgr
1587            .register_user("yara", "yara@example.com", "StrongP@ss1!")
1588            .await
1589            .unwrap();
1590        let username = mgr.get_username_by_id(&id).await.unwrap();
1591        assert_eq!(username, "yara");
1592    }
1593
1594    #[tokio::test]
1595    async fn test_get_username_by_id_not_found() {
1596        let mgr = make_manager();
1597        assert!(mgr.get_username_by_id("ghost").await.is_err());
1598    }
1599
1600    // ── list_users active_only filter ───────────────────────────────────
1601
1602    #[tokio::test]
1603    async fn test_list_users_active_only() {
1604        let mgr = make_manager();
1605        let id1 = mgr
1606            .register_user("active1", "active1@example.com", "StrongP@ss1!")
1607            .await
1608            .unwrap();
1609        let id2 = mgr
1610            .register_user("inactive1", "inactive1@example.com", "StrongP@ss1!")
1611            .await
1612            .unwrap();
1613        mgr.set_user_active(&id2, false).await.unwrap();
1614
1615        let all = mgr.list_users(None, None, false).await.unwrap();
1616        let active = mgr.list_users(None, None, true).await.unwrap();
1617        assert!(all.len() > active.len());
1618        assert!(active.iter().all(|u| u.active));
1619        // The inactive user should still be in the "all" list
1620        assert!(all.iter().any(|u| u.id == id1));
1621        assert!(all.iter().any(|u| u.id == id2));
1622    }
1623}