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    /// KV row name for an API key: a domain-separated one-way digest, never
51    /// the raw key.
52    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    /// The pre-fix row name (the raw key). Read only to migrate or delete.
60    fn legacy_api_key_storage_key(api_key: &str) -> String {
61        format!("api_key:{api_key}")
62    }
63
64    /// Tombstone written by a revoke, so a migration that read the legacy row
65    /// before the revoke and writes the digest row after it can tell, and take
66    /// its row back out. Short-lived: it only has to outlast an in-flight
67    /// migration, and a revoke removes the legacy row that migrations read.
68    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    /// Fetch an API key's row, migrating one stored under the legacy name:
76    /// write the row under the digest name, then delete the legacy row.
77    ///
78    /// This release's storage trait has no create-if-absent, so races are
79    /// settled by ordering and a revoke marker rather than by who created the
80    /// row. Several readers may migrate at once: they write identical rows and
81    /// each deletes the legacy name, which is harmless. A revoke deletes the
82    /// legacy row, the digest row and leaves a marker; a migration that wrote
83    /// its digest row after the revoke finds the marker and removes the row
84    /// again. The migrated row's lifetime comes from its own `expires_at`.
85    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            // Not under the legacy name either: a migration that ran between
92            // the two reads has moved the row, so read the digest name again.
93            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            // expired: do not recreate it; the caller rejects it from the row
103            Some(left) if left <= chrono::Duration::zero() => return Ok(Some(row)),
104            // whole seconds, rounded up: the Redis backends cannot take less
105            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            // revoked while we were migrating: take the new row back out
119            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    /// Create API key for a user.
127    ///
128    /// # Example
129    /// ```rust,ignore
130    /// let key = um.create_api_key("user-1", Some(Duration::from_secs(86400))).await?;
131    /// ```
132    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        // Generate a secure API key
140        let api_key = format!("ak_{}", crate::utils::crypto::generate_token(32));
141
142        // Store API key metadata
143        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        // The raw key is a bearer credential: the row is named by a one-way
150        // digest so a reader of the store cannot recover working keys.
151        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    /// Validate API key and return user information.
161    ///
162    /// # Example
163    /// ```rust,ignore
164    /// let info = um.validate_api_key("ak_abc123").await?;
165    /// println!("user: {}", info.username);
166    /// ```
167    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                // The key stops working with its account: deactivated, or the account's
176                // credentials reset after the key was made.
177                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                // A row with no readable creation time predates the check: treat it as made at
183                // the epoch, so any reset of the account ends it.
184                crate::account_state::ensure_issued_after_revocation(
185                    &*self.storage,
186                    user_id,
187                    created_ms.unwrap_or(0),
188                )
189                .await?;
190                // Check expiration
191                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                // Return user information
202                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    /// Revoke API key.
221    ///
222    /// # Example
223    /// ```rust,ignore
224    /// um.revoke_api_key("ak_abc123").await?;
225    /// ```
226    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        // Legacy name first: a migration writes the digest row before it
232        // deletes the legacy row, so a row is always visible under one of the
233        // two names when read in this order.
234        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            // Marker first, so a migration that read the legacy row earlier
238            // and writes the digest row after this revoke removes it again.
239            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            // Both names (a key may exist under either, or both mid-migration),
247            // legacy first so a migration in flight cannot recreate the row.
248            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    /// Validate username format.
258    ///
259    /// # Example
260    /// ```rust,ignore
261    /// assert!(um.validate_username("alice").await?);
262    /// assert!(!um.validate_username("").await?);
263    /// ```
264    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    /// Validate display name format.
277    ///
278    /// # Example
279    /// ```rust,ignore
280    /// assert!(um.validate_display_name("Alice B.").await?);
281    /// ```
282    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    /// Validate password strength using security policy.
293    ///
294    /// Requires Strong or VeryStrong to protect production deployments.
295    ///
296    /// # Example
297    /// ```rust,ignore
298    /// assert!(um.validate_password_strength("C0mpl3x!Pa$$word").await?);
299    /// assert!(!um.validate_password_strength("weak").await?);
300    /// ```
301    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    /// Validate user input for security.
316    ///
317    /// Combines a character whitelist with pattern checks for common injection
318    /// vectors. Rejects HTML tags, null bytes, path traversal sequences,
319    /// template injection markers, and dangerous URI schemes.
320    ///
321    /// # Example
322    /// ```rust,ignore
323    /// assert!(um.validate_user_input("hello world").await?);
324    /// assert!(!um.validate_user_input("<script>alert(1)</script>").await?);
325    /// ```
326    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        // Character whitelist: reject control characters and angle brackets.
334        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    /// Get user information by ID.
377    ///
378    /// # Example
379    /// ```rust,ignore
380    /// let info = um.get_user_info("user-1").await?;
381    /// println!("username: {}", info.username);
382    /// ```
383    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    /// List users from the canonical user index.
415    ///
416    /// # Example
417    /// ```rust,ignore
418    /// let users = um.list_users(Some(10), Some(0), true).await?;
419    /// for u in &users { println!("{}", u.username); }
420    /// ```
421    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    /// Check if user exists.
453    ///
454    /// # Example
455    /// ```rust,ignore
456    /// if um.user_exists("user-1").await? {
457    ///     println!("user found");
458    /// }
459    /// ```
460    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    // ────────────────────────────────────────────────────────────────────────
472    // Full user lifecycle management (migrated from auth.rs::AuthFramework)
473    // ────────────────────────────────────────────────────────────────────────
474
475    /// Register a new user, creating all required storage records.
476    ///
477    /// # Example
478    /// ```rust,ignore
479    /// let uid = um.register_user("alice", "alice@example.com", "Str0ng!Pass").await?;
480    /// println!("registered user: {}", uid);
481    /// ```
482    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        // Maintain global user index for admin listing.
529        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        // Store Argon2 credentials record for authenticate_password_builtin.
542        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    /// Delete a user and all associated storage records.
570    ///
571    /// # Example
572    /// ```rust,ignore
573    /// um.delete_user("alice").await?;
574    /// ```
575    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        // Remove email reverse-lookup.
589        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        // Remove from global index.
606        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        // Whatever the account was issued stops working with it.
656        crate::account_state::revoke_user_credentials(&*self.storage, &user_id).await?;
657
658        info!("User '{}' deleted successfully", username);
659        Ok(())
660    }
661
662    /// Delete a user by canonical user ID.
663    ///
664    /// # Example
665    /// ```rust,ignore
666    /// um.delete_user_by_id("user-1").await?;
667    /// ```
668    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    /// Update the roles assigned to a user.
674    ///
675    /// # Example
676    /// ```rust,ignore
677    /// um.update_user_roles("user-1", &["admin".into(), "editor".into()]).await?;
678    /// ```
679    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    /// Enable or disable a user account.
698    ///
699    /// # Example
700    /// ```rust,ignore
701    /// um.set_user_active("user-1", false).await?; // disable
702    /// ```
703    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    /// Update the email address stored on a user.
725    ///
726    /// # Example
727    /// ```rust,ignore
728    /// um.update_user_email("user-1", "new@example.com").await?;
729    /// ```
730    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    /// Verify a user's password against the stored bcrypt hash.
771    ///
772    /// # Example
773    /// ```rust,ignore
774    /// let ok = um.verify_user_password("user-1", "secret").await?;
775    /// assert!(ok);
776    /// ```
777    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    /// Resolve a user_id to its username.
794    ///
795    /// # Example
796    /// ```rust,ignore
797    /// let name = um.get_username_by_id("user-1").await?;
798    /// ```
799    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    /// Check whether a username is already taken.
815    ///
816    /// # Example
817    /// ```rust,ignore
818    /// if um.username_exists("alice").await? {
819    ///     println!("taken");
820    /// }
821    /// ```
822    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    /// Check whether an email address is already registered.
831    ///
832    /// # Example
833    /// ```rust,ignore
834    /// if um.email_exists("a@b.com").await? {
835    ///     println!("already registered");
836    /// }
837    /// ```
838    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    /// Fetch raw user data by username.
847    ///
848    /// # Example
849    /// ```rust,ignore
850    /// let data = um.get_user_by_username("alice").await?;
851    /// println!("email: {:?}", data.get("email"));
852    /// ```
853    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    /// Get a sanitised user profile (no password hash) for display/API.
886    ///
887    /// # Example
888    /// ```rust,ignore
889    /// let profile = um.get_user_profile("user-1").await?;
890    /// println!("email: {:?}", profile.email);
891    /// ```
892    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    /// Get a user's roles/scopes from storage, returning `["user"]` as fallback.
934    ///
935    /// # Example
936    /// ```rust,ignore
937    /// let roles = um.get_user_roles("user-1").await?;
938    /// assert!(roles.contains(&"user".to_string()));
939    /// ```
940    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    /// Verify username/password credentials in a timing-safe manner.
958    ///
959    /// Returns `Ok(None)` when the credentials are invalid — a dummy Argon2
960    /// verification is always executed when the username is not found, so
961    /// callers cannot distinguish missing users from wrong passwords via timing.
962    /// Returns `Ok(Some(result))` on success.
963    ///
964    /// # Example
965    /// ```rust,ignore
966    /// match um.verify_login_credentials("alice", "password123").await? {
967    ///     Some(cred) => println!("user_id={}, mfa={}", cred.user_id, cred.mfa_enabled),
968    ///     None => println!("invalid credentials"),
969    /// }
970    /// ```
971    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                // Constant-time: always do real work even for missing users.
987                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        // Check whether the account has been deactivated.
1014        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    /// Update a user's password by username.
1037    ///
1038    /// # Example
1039    /// ```rust,ignore
1040    /// um.update_user_password("alice", "N3wStr0ng!Pass").await?;
1041    /// ```
1042    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        // Update Argon2 credentials record used by the login endpoint.
1075        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        // Credentials issued under the old password end with it.
1091        crate::account_state::revoke_user_credentials(&*self.storage, &user_id).await?;
1092
1093        info!("Password updated for user: {}", username);
1094        Ok(())
1095    }
1096
1097    /// Update a user password by canonical user ID.
1098    ///
1099    /// # Example
1100    /// ```rust,ignore
1101    /// um.update_user_password_by_id("user-1", "N3wStr0ng!Pass").await?;
1102    /// ```
1103    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    // ── register_user ───────────────────────────────────────────────────
1123
1124    #[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    // ── get_user_info ───────────────────────────────────────────────────
1159
1160    #[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    // ── user_exists ─────────────────────────────────────────────────────
1179
1180    #[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    // ── delete_user ─────────────────────────────────────────────────────
1203
1204    #[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    // ── list_users ──────────────────────────────────────────────────────
1233
1234    #[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    // ── verify_user_password ────────────────────────────────────────────
1258
1259    #[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    // ── update_user_password ────────────────────────────────────────────
1286
1287    #[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    // ── update_user_roles ───────────────────────────────────────────────
1316
1317    #[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    // ── set_user_active ─────────────────────────────────────────────────
1342
1343    #[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    // ── update_user_email ───────────────────────────────────────────────
1362
1363    #[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    // ── API key operations ──────────────────────────────────────────────
1395
1396    #[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    // ── validate_username ───────────────────────────────────────────────
1434
1435    #[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    // ── validate_display_name ───────────────────────────────────────────
1454
1455    #[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    // ── validate_password_strength ──────────────────────────────────────
1474
1475    #[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    // ── validate_user_input ─────────────────────────────────────────────
1492
1493    #[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    // ── username_exists / email_exists ───────────────────────────────────
1554
1555    #[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    // ── get_user_by_username ────────────────────────────────────────────
1576
1577    #[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    // ── get_user_profile ────────────────────────────────────────────────
1594
1595    #[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        // password_hash should NOT be in additional_data
1606        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    // ── get_user_roles ──────────────────────────────────────────────────
1616
1617    #[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    // ── verify_login_credentials ────────────────────────────────────────
1636
1637    #[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    // ── get_username_by_id ──────────────────────────────────────────────
1707
1708    #[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    // ── list_users active_only filter ───────────────────────────────────
1726
1727    #[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        // The inactive user should still be in the "all" list
1745        assert!(all.iter().any(|u| u.id == id1));
1746        assert!(all.iter().any(|u| u.id == id2));
1747    }
1748}