Skip to main content

auth_framework/auth_modular/
authorization_manager.rs

1//! Authorization manager: wraps `PermissionChecker` and exposes all role/permission operations.
2
3use crate::errors::{AuthError, Result};
4use crate::permissions::{Permission, PermissionChecker, Role};
5use crate::storage::AuthStorage;
6use crate::tokens::AuthToken;
7use std::sync::Arc;
8use tokio::sync::RwLock;
9use tracing::{debug, info};
10
11/// Authorization manager that owns the `PermissionChecker` and exposes
12/// all role and permission operations for delegation from `AuthFramework`.
13///
14/// # Example
15/// ```rust,ignore
16/// use auth_framework::auth_modular::AuthorizationManager;
17/// let am = AuthorizationManager::new(checker.clone(), storage.clone());
18/// am.create_default_roles().await;
19/// ```
20pub struct AuthorizationManager {
21    checker: Arc<RwLock<PermissionChecker>>,
22    storage: Arc<dyn AuthStorage>,
23}
24
25impl AuthorizationManager {
26    /// Create a new authorization manager.
27    ///
28    /// # Example
29    /// ```rust,ignore
30    /// let am = AuthorizationManager::new(checker.clone(), storage.clone());
31    /// ```
32    pub fn new(checker: Arc<RwLock<PermissionChecker>>, storage: Arc<dyn AuthStorage>) -> Self {
33        Self { checker, storage }
34    }
35
36    /// Initialize the default roles in the permission checker (called during framework init).
37    ///
38    /// # Example
39    /// ```rust,ignore
40    /// am.create_default_roles().await;
41    /// ```
42    pub async fn create_default_roles(&self) {
43        let mut c = self.checker.write().await;
44        c.create_default_roles();
45    }
46
47    /// Load persisted roles and user→role assignments from KV storage into
48    /// the in-memory permission checker. Called during framework initialization
49    /// after `create_default_roles` so that previously persisted state survives
50    /// process restarts.
51    ///
52    /// # Example
53    /// ```rust,ignore
54    /// am.load_persisted_roles().await?;
55    /// ```
56    pub async fn load_persisted_roles(&self) -> Result<()> {
57        // Load roles
58        let role_keys = self.storage.list_kv_keys("rbac:role:").await?;
59        if !role_keys.is_empty() {
60            let mut c = self.checker.write().await;
61            for key in &role_keys {
62                if let Some(bytes) = self.storage.get_kv(key).await?
63                    && let Ok(role) = serde_json::from_slice::<Role>(&bytes)
64                {
65                    c.add_role(role);
66                }
67            }
68        }
69
70        // Load user→role assignments
71        let assignment_keys = self.storage.list_kv_keys("rbac:user_roles:").await?;
72        if !assignment_keys.is_empty() {
73            let mut c = self.checker.write().await;
74            for key in &assignment_keys {
75                let user_id = key.strip_prefix("rbac:user_roles:").unwrap_or(key);
76                if let Some(bytes) = self.storage.get_kv(key).await?
77                    && let Ok(roles) = serde_json::from_slice::<Vec<String>>(&bytes)
78                {
79                    for role_name in roles {
80                        if let Err(e) = c.assign_role_to_user(user_id, &role_name) {
81                            tracing::warn!(
82                                "Failed to assign role '{}' to user '{}': {}",
83                                role_name,
84                                user_id,
85                                e
86                            );
87                        }
88                    }
89                }
90            }
91        }
92
93        Ok(())
94    }
95
96    /// Reset runtime authorization state back to the default role set.
97    ///
98    /// # Example
99    /// ```rust,ignore
100    /// am.reset_runtime_state().await;
101    /// ```
102    pub async fn reset_runtime_state(&self) {
103        let mut c = self.checker.write().await;
104        c.clear();
105        c.create_default_roles();
106
107        // Clean up persisted role data
108        if let Ok(keys) = self.storage.list_kv_keys("rbac:role:").await {
109            for key in keys {
110                let _ = self.storage.delete_kv(&key).await;
111            }
112        }
113        if let Ok(keys) = self.storage.list_kv_keys("rbac:user_roles:").await {
114            for key in keys {
115                let _ = self.storage.delete_kv(&key).await;
116            }
117        }
118    }
119
120    /// Grant a direct permission to a user.
121    ///
122    /// # Example
123    /// ```rust,ignore
124    /// am.grant_permission("user-1", "read", "documents").await?;
125    /// ```
126    pub async fn grant_permission(
127        &self,
128        user_id: &str,
129        action: &str,
130        resource: &str,
131    ) -> Result<()> {
132        debug!(
133            "Granting permission '{}:{}' to user '{}'",
134            action, resource, user_id
135        );
136        let mut c = self.checker.write().await;
137        let permission = Permission::new(action, resource);
138        c.add_user_permission(user_id, permission);
139        info!(
140            "Permission '{}:{}' granted to user '{}'",
141            action, resource, user_id
142        );
143        Ok(())
144    }
145
146    /// Revoke a direct permission from a user.
147    ///
148    /// # Example
149    /// ```rust,ignore
150    /// am.revoke_permission("user-1", "read", "documents").await?;
151    /// ```
152    pub async fn revoke_permission(
153        &self,
154        user_id: &str,
155        action: &str,
156        resource: &str,
157    ) -> Result<()> {
158        debug!(
159            "Revoking permission '{}:{}' from user '{}'",
160            action, resource, user_id
161        );
162        if user_id.is_empty() || action.is_empty() || resource.is_empty() {
163            return Err(AuthError::validation(
164                "User ID, action, and resource cannot be empty",
165            ));
166        }
167        let mut c = self.checker.write().await;
168        let permission = Permission::new(action, resource);
169        c.remove_user_permission(user_id, &permission);
170        info!(
171            "Permission '{}:{}' revoked from user '{}'",
172            action, resource, user_id
173        );
174        Ok(())
175    }
176
177    /// Create (register) a new role.
178    ///
179    /// # Example
180    /// ```rust,ignore
181    /// use auth_framework::permissions::Role;
182    /// am.create_role(Role::new("editor")).await?;
183    /// ```
184    pub async fn create_role(&self, role: Role) -> Result<()> {
185        debug!("Creating role '{}'", role.name);
186        if role.name.is_empty() {
187            return Err(AuthError::validation("Role name cannot be empty"));
188        }
189        let mut c = self.checker.write().await;
190        c.add_role(role.clone());
191        drop(c);
192
193        // Persist to storage
194        let key = format!("rbac:role:{}", role.name);
195        let role_json = serde_json::to_vec(&role)
196            .map_err(|e| AuthError::internal(format!("Failed to serialize role: {e}")))?;
197        self.storage.store_kv(&key, &role_json, None).await?;
198
199        info!("Role '{}' created", role.name);
200        Ok(())
201    }
202
203    /// Return all known roles.
204    ///
205    /// # Example
206    /// ```rust,ignore
207    /// let roles = am.list_roles().await;
208    /// for r in &roles { println!("{}", r.name); }
209    /// ```
210    pub async fn list_roles(&self) -> Vec<Role> {
211        let c = self.checker.read().await;
212        c.list_roles()
213    }
214
215    /// Fetch a role definition by name.
216    ///
217    /// # Example
218    /// ```rust,ignore
219    /// let role = am.get_role("admin").await?;
220    /// println!("permissions: {:?}", role.permissions());
221    /// ```
222    pub async fn get_role(&self, role_name: &str) -> Result<Role> {
223        if role_name.is_empty() {
224            return Err(AuthError::validation("Role name cannot be empty"));
225        }
226
227        let c = self.checker.read().await;
228        c.get_role(role_name)
229            .cloned()
230            .ok_or_else(|| AuthError::validation(format!("Role '{role_name}' not found")))
231    }
232
233    /// Add a permission to an existing role.
234    ///
235    /// # Example
236    /// ```rust,ignore
237    /// use auth_framework::permissions::Permission;
238    /// am.add_role_permission("editor", Permission::new("write", "posts")).await?;
239    /// ```
240    pub async fn add_role_permission(&self, role_name: &str, permission: Permission) -> Result<()> {
241        if role_name.is_empty() {
242            return Err(AuthError::validation("Role name cannot be empty"));
243        }
244
245        let mut c = self.checker.write().await;
246        let role = c
247            .get_role(role_name)
248            .cloned()
249            .ok_or_else(|| AuthError::validation(format!("Role '{role_name}' not found")))?;
250        let mut updated_role = role;
251        updated_role.add_permission(permission);
252        c.add_role(updated_role.clone());
253        drop(c);
254
255        // Re-persist the updated role
256        let key = format!("rbac:role:{}", role_name);
257        let role_json = serde_json::to_vec(&updated_role)
258            .map_err(|e| AuthError::internal(format!("Failed to serialize role: {e}")))?;
259        self.storage.store_kv(&key, &role_json, None).await?;
260
261        Ok(())
262    }
263
264    /// Assign a role to a user.
265    ///
266    /// # Example
267    /// ```rust,ignore
268    /// am.assign_role("user-1", "editor").await?;
269    /// ```
270    pub async fn assign_role(&self, user_id: &str, role_name: &str) -> Result<()> {
271        debug!("Assigning role '{}' to user '{}'", role_name, user_id);
272        if user_id.is_empty() {
273            return Err(AuthError::validation("User ID cannot be empty"));
274        }
275        if role_name.is_empty() {
276            return Err(AuthError::validation("Role name cannot be empty"));
277        }
278        let mut c = self.checker.write().await;
279        c.assign_role_to_user(user_id, role_name)?;
280        let roles = c.get_user_roles(user_id);
281        drop(c);
282
283        // Persist user→roles mapping to storage
284        let key = format!("rbac:user_roles:{}", user_id);
285        let roles_json = serde_json::to_vec(&roles)
286            .map_err(|e| AuthError::internal(format!("Failed to serialize user roles: {e}")))?;
287        self.storage.store_kv(&key, &roles_json, None).await?;
288
289        info!("Role '{}' assigned to user '{}'", role_name, user_id);
290        Ok(())
291    }
292
293    /// Remove a role from a user.
294    ///
295    /// # Example
296    /// ```rust,ignore
297    /// am.remove_role("user-1", "editor").await?;
298    /// ```
299    pub async fn remove_role(&self, user_id: &str, role_name: &str) -> Result<()> {
300        debug!("Removing role '{}' from user '{}'", role_name, user_id);
301        if user_id.is_empty() || role_name.is_empty() {
302            return Err(AuthError::validation(
303                "User ID and role name cannot be empty",
304            ));
305        }
306        let mut c = self.checker.write().await;
307        c.remove_user_role(user_id, role_name);
308        let roles = c.get_user_roles(user_id);
309        drop(c);
310
311        // Update persisted user→roles mapping
312        let key = format!("rbac:user_roles:{}", user_id);
313        if roles.is_empty() {
314            let _ = self.storage.delete_kv(&key).await;
315        } else {
316            let roles_json = serde_json::to_vec(&roles)
317                .map_err(|e| AuthError::internal(format!("Failed to serialize user roles: {e}")))?;
318            self.storage.store_kv(&key, &roles_json, None).await?;
319        }
320
321        info!("Role '{}' removed from user '{}'", role_name, user_id);
322        Ok(())
323    }
324
325    /// Set role inheritance (`child_role` inherits all permissions from `parent_role`).
326    ///
327    /// # Example
328    /// ```rust,ignore
329    /// am.set_role_inheritance("moderator", "user").await?;
330    /// ```
331    pub async fn set_role_inheritance(&self, child_role: &str, parent_role: &str) -> Result<()> {
332        debug!(
333            "Setting inheritance: '{}' inherits from '{}'",
334            child_role, parent_role
335        );
336        if child_role.is_empty() || parent_role.is_empty() {
337            return Err(AuthError::validation("Role names cannot be empty"));
338        }
339        let mut c = self.checker.write().await;
340        c.set_role_inheritance(child_role, parent_role)?;
341        info!(
342            "Role inheritance set: '{}' inherits from '{}'",
343            child_role, parent_role
344        );
345        Ok(())
346    }
347
348    /// Check if a token has a specific direct permission.
349    ///
350    /// Does **not** validate the token itself β€” the caller must validate
351    /// the token's signature and expiry before calling this method.
352    ///
353    /// # Example
354    /// ```rust,ignore
355    /// let allowed = am.check_token_permission(&token, "read", "users").await?;
356    /// ```
357    pub async fn check_token_permission(
358        &self,
359        token: &AuthToken,
360        action: &str,
361        resource: &str,
362    ) -> Result<bool> {
363        let permission = Permission::new(action, resource);
364        let mut c = self.checker.write().await;
365        c.check_token_permission(token, &permission)
366    }
367
368    /// Check if a user (by ID) has a specific permission (ABAC/RBAC evaluation).
369    ///
370    /// # Example
371    /// ```rust,ignore
372    /// if am.check_user_permission("user-1", "write", "posts").await {
373    ///     println!("allowed");
374    /// }
375    /// ```
376    pub async fn check_user_permission(&self, user_id: &str, action: &str, resource: &str) -> bool {
377        let permission = Permission::new(action, resource);
378        let mut c = self.checker.write().await;
379        c.check_permission(user_id, &permission).unwrap_or(false)
380    }
381
382    /// Check whether a user currently holds a named role.
383    ///
384    /// # Example
385    /// ```rust,ignore
386    /// let is_admin = am.user_has_role("user-1", "admin").await?;
387    /// ```
388    pub async fn user_has_role(&self, user_id: &str, role_name: &str) -> Result<bool> {
389        debug!("Checking if user '{}' has role '{}'", user_id, role_name);
390        if user_id.is_empty() || role_name.is_empty() {
391            return Err(AuthError::validation(
392                "User ID and role name cannot be empty",
393            ));
394        }
395        let c = self.checker.read().await;
396        let has_role = c.user_has_role(user_id, role_name);
397        debug!("User '{}' has role '{}': {}", user_id, role_name, has_role);
398        Ok(has_role)
399    }
400
401    /// Get all effective permissions for a user (direct + role-inherited).
402    ///
403    /// # Example
404    /// ```rust,ignore
405    /// let perms = am.get_effective_permissions("user-1").await?;
406    /// for p in &perms { println!("{}", p); }
407    /// ```
408    pub async fn get_effective_permissions(&self, user_id: &str) -> Result<Vec<String>> {
409        debug!("Getting effective permissions for user '{}'", user_id);
410        if user_id.is_empty() {
411            return Err(AuthError::validation("User ID cannot be empty"));
412        }
413        let c = self.checker.read().await;
414        let permissions = c.get_effective_permissions(user_id);
415        debug!(
416            "User '{}' has {} effective permissions",
417            user_id,
418            permissions.len()
419        );
420        Ok(permissions)
421    }
422
423    /// List the currently assigned runtime roles for a user.
424    ///
425    /// # Example
426    /// ```rust,ignore
427    /// let roles = am.list_user_roles("user-1").await?;
428    /// ```
429    pub async fn list_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
430        if user_id.is_empty() {
431            return Err(AuthError::validation("User ID cannot be empty"));
432        }
433
434        let c = self.checker.read().await;
435        Ok(c.get_user_roles(user_id))
436    }
437
438    /// Get raw permission metrics: `(role_count, user_count, total_direct_permission_count)`.
439    ///
440    /// # Example
441    /// ```rust,ignore
442    /// let (roles, users, perms) = am.get_metrics().await;
443    /// ```
444    pub async fn get_metrics(&self) -> (usize, usize, usize) {
445        let c = self.checker.read().await;
446        (
447            c.role_count(),
448            c.user_count(),
449            c.total_direct_permission_count(),
450        )
451    }
452
453    // ── ABAC / Storage-backed operations ────────────────────────────────────
454
455    /// Create or overwrite an ABAC policy record in storage.
456    ///
457    /// # Example
458    /// ```rust,ignore
459    /// am.create_abac_policy("time-restricted", "Business hours only").await?;
460    /// ```
461    pub async fn create_abac_policy(&self, name: &str, description: &str) -> Result<()> {
462        debug!("Creating ABAC policy '{}'", name);
463        if name.is_empty() {
464            return Err(AuthError::validation("Policy name cannot be empty"));
465        }
466        if description.is_empty() {
467            return Err(AuthError::validation("Policy description cannot be empty"));
468        }
469        let policy_data = serde_json::json!({
470            "name": name,
471            "description": description,
472            "created_at": chrono::Utc::now(),
473            "rules": [],
474            "active": true
475        });
476        let key = format!("abac:policy:{}", name);
477        let policy_json = serde_json::to_vec(&policy_data)
478            .map_err(|e| AuthError::validation(format!("Failed to serialize policy: {}", e)))?;
479        self.storage.store_kv(&key, &policy_json, None).await?;
480        info!("ABAC policy '{}' created", name);
481        Ok(())
482    }
483
484    /// Store a user attribute used in ABAC policy evaluation.
485    ///
486    /// # Example
487    /// ```rust,ignore
488    /// am.map_user_attribute("user-1", "department", "engineering").await?;
489    /// ```
490    pub async fn map_user_attribute(
491        &self,
492        user_id: &str,
493        attribute: &str,
494        value: &str,
495    ) -> Result<()> {
496        debug!(
497            "Mapping attribute '{}' = '{}' for user '{}'",
498            attribute, value, user_id
499        );
500        if user_id.is_empty() || attribute.is_empty() {
501            return Err(AuthError::validation(
502                "User ID and attribute name cannot be empty",
503            ));
504        }
505        let attrs_key = format!("user:{}:attributes", user_id);
506        let mut user_attrs = if let Some(bytes) = self.storage.get_kv(&attrs_key).await? {
507            serde_json::from_slice::<std::collections::HashMap<String, String>>(&bytes)
508                .unwrap_or_default()
509        } else {
510            std::collections::HashMap::new()
511        };
512        user_attrs.insert(attribute.to_string(), value.to_string());
513        let attrs_json = serde_json::to_vec(&user_attrs)
514            .map_err(|e| AuthError::validation(format!("Failed to serialize attributes: {}", e)))?;
515        self.storage.store_kv(&attrs_key, &attrs_json, None).await?;
516        info!("Attribute '{}' mapped for user '{}'", attribute, user_id);
517        Ok(())
518    }
519
520    /// Retrieve a single user attribute.
521    ///
522    /// # Example
523    /// ```rust,ignore
524    /// let dept = am.get_user_attribute("user-1", "department").await?;
525    /// ```
526    pub async fn get_user_attribute(
527        &self,
528        user_id: &str,
529        attribute: &str,
530    ) -> Result<Option<String>> {
531        debug!("Getting attribute '{}' for user '{}'", attribute, user_id);
532        if user_id.is_empty() || attribute.is_empty() {
533            return Err(AuthError::validation(
534                "User ID and attribute name cannot be empty",
535            ));
536        }
537        let attrs_key = format!("user:{}:attributes", user_id);
538        if let Some(bytes) = self.storage.get_kv(&attrs_key).await? {
539            let user_attrs: std::collections::HashMap<String, String> =
540                serde_json::from_slice(&bytes).unwrap_or_default();
541            Ok(user_attrs.get(attribute).cloned())
542        } else {
543            Ok(None)
544        }
545    }
546
547    /// Evaluate a permission request with full ABAC context.
548    ///
549    /// # Example
550    /// ```rust,ignore
551    /// use std::collections::HashMap;
552    /// let mut ctx = HashMap::new();
553    /// ctx.insert("time_restriction".into(), "business_hours".into());
554    /// let ok = am.check_dynamic_permission("user-1", "read", "reports", ctx).await?;
555    /// ```
556    pub async fn check_dynamic_permission(
557        &self,
558        user_id: &str,
559        action: &str,
560        resource: &str,
561        context: std::collections::HashMap<String, String>,
562    ) -> Result<bool> {
563        debug!(
564            "Checking dynamic permission for user '{}': {}:{} with context: {:?}",
565            user_id, action, resource, context
566        );
567        if user_id.is_empty() || action.is_empty() || resource.is_empty() {
568            return Err(AuthError::validation(
569                "User ID, action, and resource cannot be empty",
570            ));
571        }
572        // Load user attributes for ABAC evaluation.
573        let user_attrs_key = format!("user:{}:attributes", user_id);
574        let user_attrs = if let Some(bytes) = self.storage.get_kv(&user_attrs_key).await? {
575            serde_json::from_slice::<std::collections::HashMap<String, String>>(&bytes)
576                .unwrap_or_default()
577        } else {
578            std::collections::HashMap::new()
579        };
580        // Start with RBAC check.
581        let mut permission_granted = self.check_user_permission(user_id, action, resource).await;
582        // Apply context-based rules only when the base permission is granted.
583        if permission_granted {
584            // Time-based access control.
585            if let Some(time_restriction) = context.get("time_restriction") {
586                let current_hour = chrono::Utc::now()
587                    .format("%H")
588                    .to_string()
589                    .parse::<u32>()
590                    .unwrap_or(0);
591                if time_restriction == "business_hours" && !(9..=17).contains(&current_hour) {
592                    permission_granted = false;
593                    debug!("Access denied: outside business hours");
594                }
595            }
596            // Location-based access control.
597            if let Some(required_location) = context.get("required_location")
598                && let Some(user_location) = user_attrs.get("location")
599                && user_location != required_location
600            {
601                permission_granted = false;
602                debug!(
603                    "Access denied: user location {} != required {}",
604                    user_location, required_location
605                );
606            }
607            // Clearance-level access control.
608            if let Some(required_clearance) = context.get("required_clearance")
609                && let Some(user_clearance) = user_attrs.get("clearance_level")
610            {
611                let required_level = required_clearance.parse::<u32>().unwrap_or(0);
612                let user_level = user_clearance.parse::<u32>().unwrap_or(0);
613                if user_level < required_level {
614                    permission_granted = false;
615                    debug!(
616                        "Access denied: user clearance {} < required {}",
617                        user_level, required_level
618                    );
619                }
620            }
621        }
622        debug!(
623            "Dynamic permission check result for user '{}': {}",
624            user_id, permission_granted
625        );
626        Ok(permission_granted)
627    }
628
629    /// Register a resource in the permission system.
630    ///
631    /// # Example
632    /// ```rust,ignore
633    /// am.create_resource("documents").await?;
634    /// ```
635    pub async fn create_resource(&self, resource: &str) -> Result<()> {
636        debug!("Creating resource '{}'", resource);
637        if resource.is_empty() {
638            return Err(AuthError::validation("Resource name cannot be empty"));
639        }
640        let resource_data = serde_json::json!({
641            "name": resource,
642            "created_at": chrono::Utc::now(),
643            "active": true
644        });
645        let key = format!("resource:{}", resource);
646        let resource_json = serde_json::to_vec(&resource_data)
647            .map_err(|e| AuthError::validation(format!("Failed to serialize resource: {}", e)))?;
648        self.storage.store_kv(&key, &resource_json, None).await?;
649        info!("Resource '{}' created", resource);
650        Ok(())
651    }
652
653    /// Delegate a permission from one user to another for a limited duration.
654    ///
655    /// # Example
656    /// ```rust,ignore
657    /// am.delegate_permission(
658    ///     "admin-1", "user-2", "read", "reports",
659    ///     std::time::Duration::from_secs(3600),
660    /// ).await?;
661    /// ```
662    pub async fn delegate_permission(
663        &self,
664        delegator_id: &str,
665        delegatee_id: &str,
666        action: &str,
667        resource: &str,
668        duration: std::time::Duration,
669    ) -> Result<()> {
670        debug!(
671            "Delegating permission '{}:{}' from '{}' to '{}' for {:?}",
672            action, resource, delegator_id, delegatee_id, duration
673        );
674        if delegator_id.is_empty()
675            || delegatee_id.is_empty()
676            || action.is_empty()
677            || resource.is_empty()
678        {
679            return Err(AuthError::validation(
680                "All delegation parameters cannot be empty",
681            ));
682        }
683        if !self
684            .check_user_permission(delegator_id, action, resource)
685            .await
686        {
687            return Err(AuthError::authorization(
688                "Delegator does not have the permission to delegate",
689            ));
690        }
691        let delegation_id = uuid::Uuid::new_v4().to_string();
692        let expires_secs = std::time::SystemTime::now()
693            .checked_add(duration)
694            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
695            .map(|d| d.as_secs())
696            .unwrap_or(0);
697        let delegation_data = serde_json::json!({
698            "id": delegation_id,
699            "delegator_id": delegator_id,
700            "delegatee_id": delegatee_id,
701            "action": action,
702            "resource": resource,
703            "created_at": chrono::Utc::now(),
704            "expires_at": expires_secs
705        });
706        let key = format!("delegation:{}", delegation_id);
707        let delegation_json = serde_json::to_vec(&delegation_data)
708            .map_err(|e| AuthError::validation(format!("Failed to serialize delegation: {}", e)))?;
709        self.storage
710            .store_kv(&key, &delegation_json, Some(duration))
711            .await?;
712        // Maintain a per-delegatee index.
713        let index_key = format!("delegations_index:{}", delegatee_id);
714        let mut ids: Vec<String> = match self.storage.get_kv(&index_key).await? {
715            Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
716            None => vec![],
717        };
718        ids.push(delegation_id.clone());
719        let ids_json = serde_json::to_vec(&ids).map_err(|e| {
720            AuthError::validation(format!("Failed to serialize delegation index: {}", e))
721        })?;
722        self.storage.store_kv(&index_key, &ids_json, None).await?;
723        info!(
724            "Permission '{}:{}' delegated from '{}' to '{}' for {:?}",
725            action, resource, delegator_id, delegatee_id, duration
726        );
727        Ok(())
728    }
729
730    /// List currently active permission delegations for a user (as delegatee).
731    ///
732    /// # Example
733    /// ```rust,ignore
734    /// let delegations = am.get_active_delegations("user-2").await?;
735    /// ```
736    pub async fn get_active_delegations(&self, user_id: &str) -> Result<Vec<String>> {
737        debug!("Getting active delegations for user '{}'", user_id);
738        if user_id.is_empty() {
739            return Err(AuthError::validation("User ID cannot be empty"));
740        }
741        let index_key = format!("delegations_index:{}", user_id);
742        let delegation_ids: Vec<String> = match self.storage.get_kv(&index_key).await? {
743            Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
744            None => return Ok(vec![]),
745        };
746        let now_secs = std::time::SystemTime::now()
747            .duration_since(std::time::UNIX_EPOCH)
748            .unwrap_or_default()
749            .as_secs();
750        let mut result = Vec::new();
751        let mut active_ids = Vec::new();
752        for id in &delegation_ids {
753            let key = format!("delegation:{}", id);
754            if let Some(bytes) = self.storage.get_kv(&key).await?
755                && let Ok(data) = serde_json::from_slice::<serde_json::Value>(&bytes)
756            {
757                let expires_at = data["expires_at"].as_u64().unwrap_or(0);
758                if expires_at > now_secs {
759                    let action = data["action"].as_str().unwrap_or("unknown");
760                    let resource = data["resource"].as_str().unwrap_or("unknown");
761                    let delegator = data["delegator_id"].as_str().unwrap_or("unknown");
762                    result.push(format!(
763                        "{}:{}:delegated_from:{}",
764                        action, resource, delegator
765                    ));
766                    active_ids.push(id.clone());
767                }
768            }
769        }
770        // Prune stale entries from the index.
771        if active_ids.len() != delegation_ids.len()
772            && let Ok(pruned) = serde_json::to_vec(&active_ids)
773        {
774            let _ = self.storage.store_kv(&index_key, &pruned, None).await;
775        }
776        debug!(
777            "Found {} active delegations for user '{}'",
778            result.len(),
779            user_id
780        );
781        Ok(result)
782    }
783
784    /// Assemble aggregated permission metrics.
785    ///
786    /// `active_sessions` and `permission_checks_last_hour` are provided by the
787    /// caller so that the manager stays independent from the session and audit
788    /// subsystems.
789    ///
790    /// # Example
791    /// ```rust,ignore
792    /// let metrics = am.get_permission_metrics(42, 1000).await?;
793    /// println!("total_roles: {}", metrics["total_roles"]);
794    /// ```
795    pub async fn get_permission_metrics(
796        &self,
797        active_sessions: u64,
798        permission_checks_last_hour: u64,
799    ) -> Result<std::collections::HashMap<String, u64>> {
800        let (total_roles, total_users, total_permissions) = self.get_metrics().await;
801        let mut metrics = std::collections::HashMap::new();
802        metrics.insert(
803            "total_users_with_permissions".to_string(),
804            total_users as u64,
805        );
806        metrics.insert("total_roles".to_string(), total_roles as u64);
807        metrics.insert("total_permissions".to_string(), total_permissions as u64);
808        metrics.insert("active_sessions".to_string(), active_sessions);
809        metrics.insert(
810            "permission_checks_last_hour".to_string(),
811            permission_checks_last_hour,
812        );
813        debug!("Retrieved {} permission metrics", metrics.len());
814        Ok(metrics)
815    }
816}
817
818#[cfg(test)]
819mod tests {
820    use super::*;
821    use crate::storage::MemoryStorage;
822
823    fn make_manager() -> AuthorizationManager {
824        let checker = Arc::new(RwLock::new(PermissionChecker::new()));
825        let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
826        AuthorizationManager::new(checker, storage)
827    }
828
829    // ── create_role ─────────────────────────────────────────────────────
830
831    #[tokio::test]
832    async fn test_create_role_success() {
833        let mgr = make_manager();
834        let role = Role::new("editor");
835        assert!(mgr.create_role(role).await.is_ok());
836        let roles = mgr.list_roles().await;
837        assert!(roles.iter().any(|r| r.name == "editor"));
838    }
839
840    #[tokio::test]
841    async fn test_create_role_persists_to_storage() {
842        let mgr = make_manager();
843        mgr.create_role(Role::new("persisted_role")).await.unwrap();
844        let data = mgr
845            .storage
846            .get_kv("rbac:role:persisted_role")
847            .await
848            .unwrap();
849        assert!(data.is_some());
850        let role: Role = serde_json::from_slice(&data.unwrap()).unwrap();
851        assert_eq!(role.name, "persisted_role");
852    }
853
854    #[tokio::test]
855    async fn test_create_role_empty_name_rejected() {
856        let mgr = make_manager();
857        let role = Role::new("");
858        let err = mgr.create_role(role).await;
859        assert!(err.is_err());
860    }
861
862    #[tokio::test]
863    async fn test_create_role_duplicate_overwrites() {
864        let mgr = make_manager();
865        let mut role1 = Role::new("dup");
866        role1.description = Some("first".into());
867        mgr.create_role(role1).await.unwrap();
868
869        let mut role2 = Role::new("dup");
870        role2.description = Some("second".into());
871        mgr.create_role(role2).await.unwrap();
872
873        let fetched = mgr.get_role("dup").await.unwrap();
874        assert_eq!(fetched.description.as_deref(), Some("second"));
875    }
876
877    // ── get_role ────────────────────────────────────────────────────────
878
879    #[tokio::test]
880    async fn test_get_role_not_found() {
881        let mgr = make_manager();
882        assert!(mgr.get_role("nonexistent").await.is_err());
883    }
884
885    #[tokio::test]
886    async fn test_get_role_empty_name_rejected() {
887        let mgr = make_manager();
888        assert!(mgr.get_role("").await.is_err());
889    }
890
891    // ── assign_role ─────────────────────────────────────────────────────
892
893    #[tokio::test]
894    async fn test_assign_role_success() {
895        let mgr = make_manager();
896        mgr.create_role(Role::new("viewer")).await.unwrap();
897        mgr.assign_role("user1", "viewer").await.unwrap();
898        assert!(mgr.user_has_role("user1", "viewer").await.unwrap());
899    }
900
901    #[tokio::test]
902    async fn test_assign_role_persists_to_storage() {
903        let mgr = make_manager();
904        mgr.create_role(Role::new("writer")).await.unwrap();
905        mgr.assign_role("u2", "writer").await.unwrap();
906        let data = mgr.storage.get_kv("rbac:user_roles:u2").await.unwrap();
907        assert!(data.is_some());
908        let roles: Vec<String> = serde_json::from_slice(&data.unwrap()).unwrap();
909        assert!(roles.contains(&"writer".to_string()));
910    }
911
912    #[tokio::test]
913    async fn test_assign_role_empty_user_rejected() {
914        let mgr = make_manager();
915        mgr.create_role(Role::new("r")).await.unwrap();
916        assert!(mgr.assign_role("", "r").await.is_err());
917    }
918
919    #[tokio::test]
920    async fn test_assign_role_empty_role_rejected() {
921        let mgr = make_manager();
922        assert!(mgr.assign_role("u", "").await.is_err());
923    }
924
925    // ── remove_role ─────────────────────────────────────────────────────
926
927    #[tokio::test]
928    async fn test_remove_role_success() {
929        let mgr = make_manager();
930        mgr.create_role(Role::new("temp")).await.unwrap();
931        mgr.assign_role("u3", "temp").await.unwrap();
932        assert!(mgr.user_has_role("u3", "temp").await.unwrap());
933        mgr.remove_role("u3", "temp").await.unwrap();
934        assert!(!mgr.user_has_role("u3", "temp").await.unwrap());
935    }
936
937    #[tokio::test]
938    async fn test_remove_role_cleans_storage() {
939        let mgr = make_manager();
940        mgr.create_role(Role::new("temp")).await.unwrap();
941        mgr.assign_role("u4", "temp").await.unwrap();
942        mgr.remove_role("u4", "temp").await.unwrap();
943        let data = mgr.storage.get_kv("rbac:user_roles:u4").await.unwrap();
944        // Should be deleted when empty
945        assert!(data.is_none());
946    }
947
948    #[tokio::test]
949    async fn test_remove_role_empty_params_rejected() {
950        let mgr = make_manager();
951        assert!(mgr.remove_role("", "role").await.is_err());
952        assert!(mgr.remove_role("user", "").await.is_err());
953    }
954
955    // ── add_role_permission ─────────────────────────────────────────────
956
957    #[tokio::test]
958    async fn test_add_role_permission_success() {
959        let mgr = make_manager();
960        mgr.create_role(Role::new("admin")).await.unwrap();
961        let perm = Permission::new("write", "documents");
962        mgr.add_role_permission("admin", perm).await.unwrap();
963        let role = mgr.get_role("admin").await.unwrap();
964        assert!(
965            role.permissions
966                .iter()
967                .any(|p| p.action == "write" && p.resource == "documents")
968        );
969    }
970
971    #[tokio::test]
972    async fn test_add_role_permission_persists() {
973        let mgr = make_manager();
974        mgr.create_role(Role::new("admin2")).await.unwrap();
975        mgr.add_role_permission("admin2", Permission::new("read", "reports"))
976            .await
977            .unwrap();
978        let data = mgr
979            .storage
980            .get_kv("rbac:role:admin2")
981            .await
982            .unwrap()
983            .unwrap();
984        let role: Role = serde_json::from_slice(&data).unwrap();
985        assert!(role.permissions.iter().any(|p| p.action == "read"));
986    }
987
988    #[tokio::test]
989    async fn test_add_role_permission_nonexistent_role() {
990        let mgr = make_manager();
991        let result = mgr
992            .add_role_permission("ghost", Permission::new("x", "y"))
993            .await;
994        assert!(result.is_err());
995    }
996
997    // ── set_role_inheritance ────────────────────────────────────────────
998
999    #[tokio::test]
1000    async fn test_set_role_inheritance_success() {
1001        let mgr = make_manager();
1002        mgr.create_role(Role::new("parent")).await.unwrap();
1003        mgr.create_role(Role::new("child")).await.unwrap();
1004        assert!(mgr.set_role_inheritance("child", "parent").await.is_ok());
1005    }
1006
1007    #[tokio::test]
1008    async fn test_set_role_inheritance_empty_names_rejected() {
1009        let mgr = make_manager();
1010        assert!(mgr.set_role_inheritance("", "parent").await.is_err());
1011        assert!(mgr.set_role_inheritance("child", "").await.is_err());
1012    }
1013
1014    // ── grant_permission / check_user_permission ────────────────────────
1015
1016    #[tokio::test]
1017    async fn test_grant_and_check_permission() {
1018        let mgr = make_manager();
1019        mgr.grant_permission("u5", "read", "files").await.unwrap();
1020        assert!(mgr.check_user_permission("u5", "read", "files").await);
1021    }
1022
1023    #[tokio::test]
1024    async fn test_check_permission_not_granted() {
1025        let mgr = make_manager();
1026        assert!(!mgr.check_user_permission("u6", "delete", "files").await);
1027    }
1028
1029    #[tokio::test]
1030    async fn test_revoke_permission() {
1031        let mgr = make_manager();
1032        mgr.grant_permission("u7", "write", "data").await.unwrap();
1033        assert!(mgr.check_user_permission("u7", "write", "data").await);
1034        mgr.revoke_permission("u7", "write", "data").await.unwrap();
1035        assert!(!mgr.check_user_permission("u7", "write", "data").await);
1036    }
1037
1038    #[tokio::test]
1039    async fn test_revoke_permission_empty_params_rejected() {
1040        let mgr = make_manager();
1041        assert!(mgr.revoke_permission("", "a", "r").await.is_err());
1042        assert!(mgr.revoke_permission("u", "", "r").await.is_err());
1043        assert!(mgr.revoke_permission("u", "a", "").await.is_err());
1044    }
1045
1046    // ── user_has_role ───────────────────────────────────────────────────
1047
1048    #[tokio::test]
1049    async fn test_user_has_role_false_when_not_assigned() {
1050        let mgr = make_manager();
1051        mgr.create_role(Role::new("r")).await.unwrap();
1052        assert!(!mgr.user_has_role("u", "r").await.unwrap());
1053    }
1054
1055    #[tokio::test]
1056    async fn test_user_has_role_empty_params_rejected() {
1057        let mgr = make_manager();
1058        assert!(mgr.user_has_role("", "r").await.is_err());
1059        assert!(mgr.user_has_role("u", "").await.is_err());
1060    }
1061
1062    // ── list_user_roles ─────────────────────────────────────────────────
1063
1064    #[tokio::test]
1065    async fn test_list_user_roles() {
1066        let mgr = make_manager();
1067        mgr.create_role(Role::new("a")).await.unwrap();
1068        mgr.create_role(Role::new("b")).await.unwrap();
1069        mgr.assign_role("u8", "a").await.unwrap();
1070        mgr.assign_role("u8", "b").await.unwrap();
1071        let roles = mgr.list_user_roles("u8").await.unwrap();
1072        assert!(roles.contains(&"a".to_string()));
1073        assert!(roles.contains(&"b".to_string()));
1074    }
1075
1076    #[tokio::test]
1077    async fn test_list_user_roles_empty_user_rejected() {
1078        let mgr = make_manager();
1079        assert!(mgr.list_user_roles("").await.is_err());
1080    }
1081
1082    // ── get_effective_permissions ────────────────────────────────────────
1083
1084    #[tokio::test]
1085    async fn test_get_effective_permissions() {
1086        let mgr = make_manager();
1087        mgr.grant_permission("u9", "read", "docs").await.unwrap();
1088        let perms = mgr.get_effective_permissions("u9").await.unwrap();
1089        assert!(!perms.is_empty());
1090    }
1091
1092    #[tokio::test]
1093    async fn test_get_effective_permissions_empty_user_rejected() {
1094        let mgr = make_manager();
1095        assert!(mgr.get_effective_permissions("").await.is_err());
1096    }
1097
1098    // ── load_persisted_roles ────────────────────────────────────────────
1099
1100    #[tokio::test]
1101    async fn test_load_persisted_roles_restores_roles() {
1102        let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
1103
1104        // Create manager, add roles and assignments, then drop it
1105        {
1106            let checker = Arc::new(RwLock::new(PermissionChecker::new()));
1107            let mgr = AuthorizationManager::new(checker, storage.clone());
1108            mgr.create_role(Role::new("restored_role")).await.unwrap();
1109            mgr.assign_role("restored_user", "restored_role")
1110                .await
1111                .unwrap();
1112        }
1113
1114        // Create fresh manager with the SAME storage, load persisted data
1115        let checker2 = Arc::new(RwLock::new(PermissionChecker::new()));
1116        let mgr2 = AuthorizationManager::new(checker2, storage);
1117        mgr2.load_persisted_roles().await.unwrap();
1118
1119        assert!(mgr2.get_role("restored_role").await.is_ok());
1120        assert!(
1121            mgr2.user_has_role("restored_user", "restored_role")
1122                .await
1123                .unwrap()
1124        );
1125    }
1126
1127    #[tokio::test]
1128    async fn test_load_persisted_roles_empty_storage_ok() {
1129        let mgr = make_manager();
1130        assert!(mgr.load_persisted_roles().await.is_ok());
1131    }
1132
1133    // ── reset_runtime_state ─────────────────────────────────────────────
1134
1135    #[tokio::test]
1136    async fn test_reset_runtime_state_clears_roles() {
1137        let mgr = make_manager();
1138        mgr.create_role(Role::new("custom")).await.unwrap();
1139        mgr.assign_role("u10", "custom").await.unwrap();
1140        mgr.reset_runtime_state().await;
1141        assert!(!mgr.user_has_role("u10", "custom").await.unwrap_or(false));
1142        // Storage should also be cleaned
1143        assert!(
1144            mgr.storage
1145                .get_kv("rbac:role:custom")
1146                .await
1147                .unwrap()
1148                .is_none()
1149        );
1150        assert!(
1151            mgr.storage
1152                .get_kv("rbac:user_roles:u10")
1153                .await
1154                .unwrap()
1155                .is_none()
1156        );
1157    }
1158
1159    // ── ABAC operations ─────────────────────────────────────────────────
1160
1161    #[tokio::test]
1162    async fn test_create_abac_policy() {
1163        let mgr = make_manager();
1164        mgr.create_abac_policy("location_gate", "Restricts by location")
1165            .await
1166            .unwrap();
1167        let data = mgr
1168            .storage
1169            .get_kv("abac:policy:location_gate")
1170            .await
1171            .unwrap();
1172        assert!(data.is_some());
1173    }
1174
1175    #[tokio::test]
1176    async fn test_create_abac_policy_empty_name_rejected() {
1177        let mgr = make_manager();
1178        assert!(mgr.create_abac_policy("", "desc").await.is_err());
1179    }
1180
1181    #[tokio::test]
1182    async fn test_create_abac_policy_empty_description_rejected() {
1183        let mgr = make_manager();
1184        assert!(mgr.create_abac_policy("name", "").await.is_err());
1185    }
1186
1187    #[tokio::test]
1188    async fn test_map_and_get_user_attribute() {
1189        let mgr = make_manager();
1190        mgr.map_user_attribute("u11", "department", "engineering")
1191            .await
1192            .unwrap();
1193        let val = mgr.get_user_attribute("u11", "department").await.unwrap();
1194        assert_eq!(val.as_deref(), Some("engineering"));
1195    }
1196
1197    #[tokio::test]
1198    async fn test_get_user_attribute_nonexistent() {
1199        let mgr = make_manager();
1200        let val = mgr.get_user_attribute("nobody", "x").await.unwrap();
1201        assert!(val.is_none());
1202    }
1203
1204    #[tokio::test]
1205    async fn test_map_user_attribute_empty_params_rejected() {
1206        let mgr = make_manager();
1207        assert!(mgr.map_user_attribute("", "a", "v").await.is_err());
1208        assert!(mgr.map_user_attribute("u", "", "v").await.is_err());
1209    }
1210
1211    #[tokio::test]
1212    async fn test_get_user_attribute_empty_params_rejected() {
1213        let mgr = make_manager();
1214        assert!(mgr.get_user_attribute("", "x").await.is_err());
1215        assert!(mgr.get_user_attribute("u", "").await.is_err());
1216    }
1217
1218    // ── check_dynamic_permission ────────────────────────────────────────
1219
1220    #[tokio::test]
1221    async fn test_check_dynamic_permission_granted() {
1222        let mgr = make_manager();
1223        mgr.grant_permission("u12", "read", "reports")
1224            .await
1225            .unwrap();
1226        let ctx = std::collections::HashMap::new();
1227        assert!(
1228            mgr.check_dynamic_permission("u12", "read", "reports", ctx)
1229                .await
1230                .unwrap()
1231        );
1232    }
1233
1234    #[tokio::test]
1235    async fn test_check_dynamic_permission_denied_no_permission() {
1236        let mgr = make_manager();
1237        let ctx = std::collections::HashMap::new();
1238        assert!(
1239            !mgr.check_dynamic_permission("u13", "read", "reports", ctx)
1240                .await
1241                .unwrap()
1242        );
1243    }
1244
1245    #[tokio::test]
1246    async fn test_check_dynamic_permission_location_mismatch() {
1247        let mgr = make_manager();
1248        mgr.grant_permission("u14", "read", "files").await.unwrap();
1249        mgr.map_user_attribute("u14", "location", "US")
1250            .await
1251            .unwrap();
1252        let mut ctx = std::collections::HashMap::new();
1253        ctx.insert("required_location".to_string(), "EU".to_string());
1254        assert!(
1255            !mgr.check_dynamic_permission("u14", "read", "files", ctx)
1256                .await
1257                .unwrap()
1258        );
1259    }
1260
1261    #[tokio::test]
1262    async fn test_check_dynamic_permission_clearance_insufficient() {
1263        let mgr = make_manager();
1264        mgr.grant_permission("u15", "read", "secret").await.unwrap();
1265        mgr.map_user_attribute("u15", "clearance_level", "2")
1266            .await
1267            .unwrap();
1268        let mut ctx = std::collections::HashMap::new();
1269        ctx.insert("required_clearance".to_string(), "5".to_string());
1270        assert!(
1271            !mgr.check_dynamic_permission("u15", "read", "secret", ctx)
1272                .await
1273                .unwrap()
1274        );
1275    }
1276
1277    #[tokio::test]
1278    async fn test_check_dynamic_permission_empty_params_rejected() {
1279        let mgr = make_manager();
1280        let ctx = std::collections::HashMap::new();
1281        assert!(
1282            mgr.check_dynamic_permission("", "r", "x", ctx.clone())
1283                .await
1284                .is_err()
1285        );
1286        assert!(
1287            mgr.check_dynamic_permission("u", "", "x", ctx.clone())
1288                .await
1289                .is_err()
1290        );
1291        assert!(
1292            mgr.check_dynamic_permission("u", "r", "", ctx)
1293                .await
1294                .is_err()
1295        );
1296    }
1297
1298    // ── create_resource ─────────────────────────────────────────────────
1299
1300    #[tokio::test]
1301    async fn test_create_resource() {
1302        let mgr = make_manager();
1303        mgr.create_resource("documents").await.unwrap();
1304        let data = mgr.storage.get_kv("resource:documents").await.unwrap();
1305        assert!(data.is_some());
1306    }
1307
1308    #[tokio::test]
1309    async fn test_create_resource_empty_name_rejected() {
1310        let mgr = make_manager();
1311        assert!(mgr.create_resource("").await.is_err());
1312    }
1313
1314    // ── delegate_permission ─────────────────────────────────────────────
1315
1316    #[tokio::test]
1317    async fn test_delegate_permission_success() {
1318        let mgr = make_manager();
1319        mgr.grant_permission("delegator", "read", "files")
1320            .await
1321            .unwrap();
1322        mgr.delegate_permission(
1323            "delegator",
1324            "delegatee",
1325            "read",
1326            "files",
1327            std::time::Duration::from_secs(3600),
1328        )
1329        .await
1330        .unwrap();
1331        let delegations = mgr.get_active_delegations("delegatee").await.unwrap();
1332        assert!(!delegations.is_empty());
1333    }
1334
1335    #[tokio::test]
1336    async fn test_delegate_permission_without_holding_it() {
1337        let mgr = make_manager();
1338        let result = mgr
1339            .delegate_permission(
1340                "delegator",
1341                "delegatee",
1342                "write",
1343                "files",
1344                std::time::Duration::from_secs(3600),
1345            )
1346            .await;
1347        assert!(result.is_err());
1348    }
1349
1350    #[tokio::test]
1351    async fn test_delegate_permission_empty_params_rejected() {
1352        let mgr = make_manager();
1353        let dur = std::time::Duration::from_secs(60);
1354        assert!(
1355            mgr.delegate_permission("", "d", "a", "r", dur)
1356                .await
1357                .is_err()
1358        );
1359        assert!(
1360            mgr.delegate_permission("d", "", "a", "r", dur)
1361                .await
1362                .is_err()
1363        );
1364        assert!(
1365            mgr.delegate_permission("d", "d2", "", "r", dur)
1366                .await
1367                .is_err()
1368        );
1369        assert!(
1370            mgr.delegate_permission("d", "d2", "a", "", dur)
1371                .await
1372                .is_err()
1373        );
1374    }
1375
1376    // ── get_active_delegations ──────────────────────────────────────────
1377
1378    #[tokio::test]
1379    async fn test_get_active_delegations_empty() {
1380        let mgr = make_manager();
1381        let delegations = mgr.get_active_delegations("nobody").await.unwrap();
1382        assert!(delegations.is_empty());
1383    }
1384
1385    #[tokio::test]
1386    async fn test_get_active_delegations_empty_user_rejected() {
1387        let mgr = make_manager();
1388        assert!(mgr.get_active_delegations("").await.is_err());
1389    }
1390
1391    // ── get_permission_metrics ──────────────────────────────────────────
1392
1393    #[tokio::test]
1394    async fn test_get_permission_metrics() {
1395        let mgr = make_manager();
1396        mgr.create_default_roles().await;
1397        mgr.create_role(Role::new("custom")).await.unwrap();
1398        let metrics = mgr.get_permission_metrics(10, 100).await.unwrap();
1399        assert!(metrics.get("total_roles").copied().unwrap_or(0) > 0);
1400        assert_eq!(metrics["active_sessions"], 10);
1401        assert_eq!(metrics["permission_checks_last_hour"], 100);
1402    }
1403
1404    // ── get_metrics ─────────────────────────────────────────────────────
1405
1406    #[tokio::test]
1407    async fn test_get_metrics() {
1408        let mgr = make_manager();
1409        mgr.create_role(Role::new("m")).await.unwrap();
1410        mgr.grant_permission("u16", "a", "r").await.unwrap();
1411        let (roles, users, perms) = mgr.get_metrics().await;
1412        assert!(roles >= 1);
1413        assert!(users >= 1);
1414        assert!(perms >= 1);
1415    }
1416}