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