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    #[deprecated(
358        since = "0.6.0",
359        note = "does not validate the token; use `check_validated_permission` with a `ValidatedToken`"
360    )]
361    pub async fn check_token_permission(
362        &self,
363        token: &AuthToken,
364        action: &str,
365        resource: &str,
366    ) -> Result<bool> {
367        let permission = Permission::new(action, resource);
368        let mut c = self.checker.write().await;
369        #[allow(deprecated)]
370        c.check_token_permission(token, &permission)
371    }
372
373    /// Check whether a token the framework has validated holds a permission.
374    pub async fn check_validated_permission(
375        &self,
376        token: &crate::tokens::ValidatedToken,
377        action: &str,
378        resource: &str,
379    ) -> Result<bool> {
380        let permission = Permission::new(action, resource);
381        let mut c = self.checker.write().await;
382        c.check_validated_permission(token, &permission)
383    }
384
385    /// Check if a user (by ID) has a specific permission (ABAC/RBAC evaluation).
386    ///
387    /// # Example
388    /// ```rust,ignore
389    /// if am.check_user_permission("user-1", "write", "posts").await {
390    ///     println!("allowed");
391    /// }
392    /// ```
393    pub async fn check_user_permission(&self, user_id: &str, action: &str, resource: &str) -> bool {
394        let permission = Permission::new(action, resource);
395        let mut c = self.checker.write().await;
396        c.check_permission(user_id, &permission).unwrap_or(false)
397    }
398
399    /// Check whether a user currently holds a named role.
400    ///
401    /// # Example
402    /// ```rust,ignore
403    /// let is_admin = am.user_has_role("user-1", "admin").await?;
404    /// ```
405    pub async fn user_has_role(&self, user_id: &str, role_name: &str) -> Result<bool> {
406        debug!("Checking if user '{}' has role '{}'", user_id, role_name);
407        if user_id.is_empty() || role_name.is_empty() {
408            return Err(AuthError::validation(
409                "User ID and role name cannot be empty",
410            ));
411        }
412        let c = self.checker.read().await;
413        let has_role = c.user_has_role(user_id, role_name);
414        debug!("User '{}' has role '{}': {}", user_id, role_name, has_role);
415        Ok(has_role)
416    }
417
418    /// Get all effective permissions for a user (direct + role-inherited).
419    ///
420    /// # Example
421    /// ```rust,ignore
422    /// let perms = am.get_effective_permissions("user-1").await?;
423    /// for p in &perms { println!("{}", p); }
424    /// ```
425    pub async fn get_effective_permissions(&self, user_id: &str) -> Result<Vec<String>> {
426        debug!("Getting effective permissions for user '{}'", user_id);
427        if user_id.is_empty() {
428            return Err(AuthError::validation("User ID cannot be empty"));
429        }
430        let c = self.checker.read().await;
431        let permissions = c.get_effective_permissions(user_id);
432        debug!(
433            "User '{}' has {} effective permissions",
434            user_id,
435            permissions.len()
436        );
437        Ok(permissions)
438    }
439
440    /// List the currently assigned runtime roles for a user.
441    ///
442    /// # Example
443    /// ```rust,ignore
444    /// let roles = am.list_user_roles("user-1").await?;
445    /// ```
446    pub async fn list_user_roles(&self, user_id: &str) -> Result<Vec<String>> {
447        if user_id.is_empty() {
448            return Err(AuthError::validation("User ID cannot be empty"));
449        }
450
451        let c = self.checker.read().await;
452        Ok(c.get_user_roles(user_id))
453    }
454
455    /// Get raw permission metrics: `(role_count, user_count, total_direct_permission_count)`.
456    ///
457    /// # Example
458    /// ```rust,ignore
459    /// let (roles, users, perms) = am.get_metrics().await;
460    /// ```
461    pub async fn get_metrics(&self) -> (usize, usize, usize) {
462        let c = self.checker.read().await;
463        (
464            c.role_count(),
465            c.user_count(),
466            c.total_direct_permission_count(),
467        )
468    }
469
470    // ── ABAC / Storage-backed operations ────────────────────────────────────
471
472    /// Create or overwrite an ABAC policy record in storage.
473    ///
474    /// # Example
475    /// ```rust,ignore
476    /// am.create_abac_policy("time-restricted", "Business hours only").await?;
477    /// ```
478    pub async fn create_abac_policy(&self, name: &str, description: &str) -> Result<()> {
479        debug!("Creating ABAC policy '{}'", name);
480        if name.is_empty() {
481            return Err(AuthError::validation("Policy name cannot be empty"));
482        }
483        if description.is_empty() {
484            return Err(AuthError::validation("Policy description cannot be empty"));
485        }
486        let policy_data = serde_json::json!({
487            "name": name,
488            "description": description,
489            "created_at": chrono::Utc::now(),
490            "rules": [],
491            "active": true
492        });
493        let key = format!("abac:policy:{}", name);
494        let policy_json = serde_json::to_vec(&policy_data)
495            .map_err(|e| AuthError::validation(format!("Failed to serialize policy: {}", e)))?;
496        self.storage.store_kv(&key, &policy_json, None).await?;
497        info!("ABAC policy '{}' created", name);
498        Ok(())
499    }
500
501    /// Store a user attribute used in ABAC policy evaluation.
502    ///
503    /// # Example
504    /// ```rust,ignore
505    /// am.map_user_attribute("user-1", "department", "engineering").await?;
506    /// ```
507    pub async fn map_user_attribute(
508        &self,
509        user_id: &str,
510        attribute: &str,
511        value: &str,
512    ) -> Result<()> {
513        debug!(
514            "Mapping attribute '{}' = '{}' for user '{}'",
515            attribute, value, user_id
516        );
517        if user_id.is_empty() || attribute.is_empty() {
518            return Err(AuthError::validation(
519                "User ID and attribute name cannot be empty",
520            ));
521        }
522        let attrs_key = format!("user:{}:attributes", user_id);
523        let mut user_attrs = if let Some(bytes) = self.storage.get_kv(&attrs_key).await? {
524            serde_json::from_slice::<std::collections::HashMap<String, String>>(&bytes)
525                .unwrap_or_default()
526        } else {
527            std::collections::HashMap::new()
528        };
529        user_attrs.insert(attribute.to_string(), value.to_string());
530        let attrs_json = serde_json::to_vec(&user_attrs)
531            .map_err(|e| AuthError::validation(format!("Failed to serialize attributes: {}", e)))?;
532        self.storage.store_kv(&attrs_key, &attrs_json, None).await?;
533        info!("Attribute '{}' mapped for user '{}'", attribute, user_id);
534        Ok(())
535    }
536
537    /// Retrieve a single user attribute.
538    ///
539    /// # Example
540    /// ```rust,ignore
541    /// let dept = am.get_user_attribute("user-1", "department").await?;
542    /// ```
543    pub async fn get_user_attribute(
544        &self,
545        user_id: &str,
546        attribute: &str,
547    ) -> Result<Option<String>> {
548        debug!("Getting attribute '{}' for user '{}'", attribute, user_id);
549        if user_id.is_empty() || attribute.is_empty() {
550            return Err(AuthError::validation(
551                "User ID and attribute name cannot be empty",
552            ));
553        }
554        let attrs_key = format!("user:{}:attributes", user_id);
555        if let Some(bytes) = self.storage.get_kv(&attrs_key).await? {
556            let user_attrs: std::collections::HashMap<String, String> =
557                serde_json::from_slice(&bytes).unwrap_or_default();
558            Ok(user_attrs.get(attribute).cloned())
559        } else {
560            Ok(None)
561        }
562    }
563
564    /// Evaluate a permission request with full ABAC context.
565    ///
566    /// # Example
567    /// ```rust,ignore
568    /// use std::collections::HashMap;
569    /// let mut ctx = HashMap::new();
570    /// ctx.insert("time_restriction".into(), "business_hours".into());
571    /// let ok = am.check_dynamic_permission("user-1", "read", "reports", ctx).await?;
572    /// ```
573    pub async fn check_dynamic_permission(
574        &self,
575        user_id: &str,
576        action: &str,
577        resource: &str,
578        context: std::collections::HashMap<String, String>,
579    ) -> Result<bool> {
580        debug!(
581            "Checking dynamic permission for user '{}': {}:{} with context: {:?}",
582            user_id, action, resource, context
583        );
584        if user_id.is_empty() || action.is_empty() || resource.is_empty() {
585            return Err(AuthError::validation(
586                "User ID, action, and resource cannot be empty",
587            ));
588        }
589        // Load user attributes for ABAC evaluation.
590        let user_attrs_key = format!("user:{}:attributes", user_id);
591        let user_attrs = if let Some(bytes) = self.storage.get_kv(&user_attrs_key).await? {
592            serde_json::from_slice::<std::collections::HashMap<String, String>>(&bytes)
593                .unwrap_or_default()
594        } else {
595            std::collections::HashMap::new()
596        };
597        // Start with RBAC check.
598        let mut permission_granted = self.check_user_permission(user_id, action, resource).await;
599        // Apply context-based rules only when the base permission is granted.
600        if permission_granted {
601            // Time-based access control.
602            if let Some(time_restriction) = context.get("time_restriction") {
603                let current_hour = chrono::Utc::now()
604                    .format("%H")
605                    .to_string()
606                    .parse::<u32>()
607                    .unwrap_or(0);
608                if time_restriction == "business_hours" && !(9..=17).contains(&current_hour) {
609                    permission_granted = false;
610                    debug!("Access denied: outside business hours");
611                }
612            }
613            // Location-based access control.
614            if let Some(required_location) = context.get("required_location")
615                && let Some(user_location) = user_attrs.get("location")
616                && user_location != required_location
617            {
618                permission_granted = false;
619                debug!(
620                    "Access denied: user location {} != required {}",
621                    user_location, required_location
622                );
623            }
624            // Clearance-level access control.
625            if let Some(required_clearance) = context.get("required_clearance")
626                && let Some(user_clearance) = user_attrs.get("clearance_level")
627            {
628                let required_level = required_clearance.parse::<u32>().unwrap_or(0);
629                let user_level = user_clearance.parse::<u32>().unwrap_or(0);
630                if user_level < required_level {
631                    permission_granted = false;
632                    debug!(
633                        "Access denied: user clearance {} < required {}",
634                        user_level, required_level
635                    );
636                }
637            }
638        }
639        debug!(
640            "Dynamic permission check result for user '{}': {}",
641            user_id, permission_granted
642        );
643        Ok(permission_granted)
644    }
645
646    /// Register a resource in the permission system.
647    ///
648    /// # Example
649    /// ```rust,ignore
650    /// am.create_resource("documents").await?;
651    /// ```
652    pub async fn create_resource(&self, resource: &str) -> Result<()> {
653        debug!("Creating resource '{}'", resource);
654        if resource.is_empty() {
655            return Err(AuthError::validation("Resource name cannot be empty"));
656        }
657        let resource_data = serde_json::json!({
658            "name": resource,
659            "created_at": chrono::Utc::now(),
660            "active": true
661        });
662        let key = format!("resource:{}", resource);
663        let resource_json = serde_json::to_vec(&resource_data)
664            .map_err(|e| AuthError::validation(format!("Failed to serialize resource: {}", e)))?;
665        self.storage.store_kv(&key, &resource_json, None).await?;
666        info!("Resource '{}' created", resource);
667        Ok(())
668    }
669
670    /// Delegate a permission from one user to another for a limited duration.
671    ///
672    /// # Example
673    /// ```rust,ignore
674    /// am.delegate_permission(
675    ///     "admin-1", "user-2", "read", "reports",
676    ///     std::time::Duration::from_secs(3600),
677    /// ).await?;
678    /// ```
679    pub async fn delegate_permission(
680        &self,
681        delegator_id: &str,
682        delegatee_id: &str,
683        action: &str,
684        resource: &str,
685        duration: std::time::Duration,
686    ) -> Result<()> {
687        debug!(
688            "Delegating permission '{}:{}' from '{}' to '{}' for {:?}",
689            action, resource, delegator_id, delegatee_id, duration
690        );
691        if delegator_id.is_empty()
692            || delegatee_id.is_empty()
693            || action.is_empty()
694            || resource.is_empty()
695        {
696            return Err(AuthError::validation(
697                "All delegation parameters cannot be empty",
698            ));
699        }
700        if !self
701            .check_user_permission(delegator_id, action, resource)
702            .await
703        {
704            return Err(AuthError::authorization(
705                "Delegator does not have the permission to delegate",
706            ));
707        }
708        let delegation_id = uuid::Uuid::new_v4().to_string();
709        let expires_secs = std::time::SystemTime::now()
710            .checked_add(duration)
711            .and_then(|t| t.duration_since(std::time::UNIX_EPOCH).ok())
712            .map(|d| d.as_secs())
713            .unwrap_or(0);
714        let delegation_data = serde_json::json!({
715            "id": delegation_id,
716            "delegator_id": delegator_id,
717            "delegatee_id": delegatee_id,
718            "action": action,
719            "resource": resource,
720            "created_at": chrono::Utc::now(),
721            "expires_at": expires_secs
722        });
723        let key = format!("delegation:{}", delegation_id);
724        let delegation_json = serde_json::to_vec(&delegation_data)
725            .map_err(|e| AuthError::validation(format!("Failed to serialize delegation: {}", e)))?;
726        self.storage
727            .store_kv(&key, &delegation_json, Some(duration))
728            .await?;
729        // Maintain a per-delegatee index.
730        let index_key = format!("delegations_index:{}", delegatee_id);
731        let mut ids: Vec<String> = match self.storage.get_kv(&index_key).await? {
732            Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
733            None => vec![],
734        };
735        ids.push(delegation_id.clone());
736        let ids_json = serde_json::to_vec(&ids).map_err(|e| {
737            AuthError::validation(format!("Failed to serialize delegation index: {}", e))
738        })?;
739        self.storage.store_kv(&index_key, &ids_json, None).await?;
740        info!(
741            "Permission '{}:{}' delegated from '{}' to '{}' for {:?}",
742            action, resource, delegator_id, delegatee_id, duration
743        );
744        Ok(())
745    }
746
747    /// List currently active permission delegations for a user (as delegatee).
748    ///
749    /// # Example
750    /// ```rust,ignore
751    /// let delegations = am.get_active_delegations("user-2").await?;
752    /// ```
753    pub async fn get_active_delegations(&self, user_id: &str) -> Result<Vec<String>> {
754        debug!("Getting active delegations for user '{}'", user_id);
755        if user_id.is_empty() {
756            return Err(AuthError::validation("User ID cannot be empty"));
757        }
758        let index_key = format!("delegations_index:{}", user_id);
759        let delegation_ids: Vec<String> = match self.storage.get_kv(&index_key).await? {
760            Some(bytes) => serde_json::from_slice(&bytes).unwrap_or_default(),
761            None => return Ok(vec![]),
762        };
763        let now_secs = std::time::SystemTime::now()
764            .duration_since(std::time::UNIX_EPOCH)
765            .unwrap_or_default()
766            .as_secs();
767        let mut result = Vec::new();
768        let mut active_ids = Vec::new();
769        for id in &delegation_ids {
770            let key = format!("delegation:{}", id);
771            if let Some(bytes) = self.storage.get_kv(&key).await?
772                && let Ok(data) = serde_json::from_slice::<serde_json::Value>(&bytes)
773            {
774                let expires_at = data["expires_at"].as_u64().unwrap_or(0);
775                if expires_at > now_secs {
776                    let action = data["action"].as_str().unwrap_or("unknown");
777                    let resource = data["resource"].as_str().unwrap_or("unknown");
778                    let delegator = data["delegator_id"].as_str().unwrap_or("unknown");
779                    result.push(format!(
780                        "{}:{}:delegated_from:{}",
781                        action, resource, delegator
782                    ));
783                    active_ids.push(id.clone());
784                }
785            }
786        }
787        // Prune stale entries from the index.
788        if active_ids.len() != delegation_ids.len()
789            && let Ok(pruned) = serde_json::to_vec(&active_ids)
790        {
791            let _ = self.storage.store_kv(&index_key, &pruned, None).await;
792        }
793        debug!(
794            "Found {} active delegations for user '{}'",
795            result.len(),
796            user_id
797        );
798        Ok(result)
799    }
800
801    /// Assemble aggregated permission metrics.
802    ///
803    /// `active_sessions` and `permission_checks_last_hour` are provided by the
804    /// caller so that the manager stays independent from the session and audit
805    /// subsystems.
806    ///
807    /// # Example
808    /// ```rust,ignore
809    /// let metrics = am.get_permission_metrics(42, 1000).await?;
810    /// println!("total_roles: {}", metrics["total_roles"]);
811    /// ```
812    pub async fn get_permission_metrics(
813        &self,
814        active_sessions: u64,
815        permission_checks_last_hour: u64,
816    ) -> Result<std::collections::HashMap<String, u64>> {
817        let (total_roles, total_users, total_permissions) = self.get_metrics().await;
818        let mut metrics = std::collections::HashMap::new();
819        metrics.insert(
820            "total_users_with_permissions".to_string(),
821            total_users as u64,
822        );
823        metrics.insert("total_roles".to_string(), total_roles as u64);
824        metrics.insert("total_permissions".to_string(), total_permissions as u64);
825        metrics.insert("active_sessions".to_string(), active_sessions);
826        metrics.insert(
827            "permission_checks_last_hour".to_string(),
828            permission_checks_last_hour,
829        );
830        debug!("Retrieved {} permission metrics", metrics.len());
831        Ok(metrics)
832    }
833}
834
835#[cfg(test)]
836mod tests {
837    use super::*;
838    use crate::storage::MemoryStorage;
839
840    fn make_manager() -> AuthorizationManager {
841        let checker = Arc::new(RwLock::new(PermissionChecker::new()));
842        let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
843        AuthorizationManager::new(checker, storage)
844    }
845
846    // ── create_role ─────────────────────────────────────────────────────
847
848    #[tokio::test]
849    async fn test_create_role_success() {
850        let mgr = make_manager();
851        let role = Role::new("editor");
852        assert!(mgr.create_role(role).await.is_ok());
853        let roles = mgr.list_roles().await;
854        assert!(roles.iter().any(|r| r.name == "editor"));
855    }
856
857    #[tokio::test]
858    async fn test_create_role_persists_to_storage() {
859        let mgr = make_manager();
860        mgr.create_role(Role::new("persisted_role")).await.unwrap();
861        let data = mgr
862            .storage
863            .get_kv("rbac:role:persisted_role")
864            .await
865            .unwrap();
866        assert!(data.is_some());
867        let role: Role = serde_json::from_slice(&data.unwrap()).unwrap();
868        assert_eq!(role.name, "persisted_role");
869    }
870
871    #[tokio::test]
872    async fn test_create_role_empty_name_rejected() {
873        let mgr = make_manager();
874        let role = Role::new("");
875        let err = mgr.create_role(role).await;
876        assert!(err.is_err());
877    }
878
879    #[tokio::test]
880    async fn test_create_role_duplicate_overwrites() {
881        let mgr = make_manager();
882        let mut role1 = Role::new("dup");
883        role1.description = Some("first".into());
884        mgr.create_role(role1).await.unwrap();
885
886        let mut role2 = Role::new("dup");
887        role2.description = Some("second".into());
888        mgr.create_role(role2).await.unwrap();
889
890        let fetched = mgr.get_role("dup").await.unwrap();
891        assert_eq!(fetched.description.as_deref(), Some("second"));
892    }
893
894    // ── get_role ────────────────────────────────────────────────────────
895
896    #[tokio::test]
897    async fn test_get_role_not_found() {
898        let mgr = make_manager();
899        assert!(mgr.get_role("nonexistent").await.is_err());
900    }
901
902    #[tokio::test]
903    async fn test_get_role_empty_name_rejected() {
904        let mgr = make_manager();
905        assert!(mgr.get_role("").await.is_err());
906    }
907
908    // ── assign_role ─────────────────────────────────────────────────────
909
910    #[tokio::test]
911    async fn test_assign_role_success() {
912        let mgr = make_manager();
913        mgr.create_role(Role::new("viewer")).await.unwrap();
914        mgr.assign_role("user1", "viewer").await.unwrap();
915        assert!(mgr.user_has_role("user1", "viewer").await.unwrap());
916    }
917
918    #[tokio::test]
919    async fn test_assign_role_persists_to_storage() {
920        let mgr = make_manager();
921        mgr.create_role(Role::new("writer")).await.unwrap();
922        mgr.assign_role("u2", "writer").await.unwrap();
923        let data = mgr.storage.get_kv("rbac:user_roles:u2").await.unwrap();
924        assert!(data.is_some());
925        let roles: Vec<String> = serde_json::from_slice(&data.unwrap()).unwrap();
926        assert!(roles.contains(&"writer".to_string()));
927    }
928
929    #[tokio::test]
930    async fn test_assign_role_empty_user_rejected() {
931        let mgr = make_manager();
932        mgr.create_role(Role::new("r")).await.unwrap();
933        assert!(mgr.assign_role("", "r").await.is_err());
934    }
935
936    #[tokio::test]
937    async fn test_assign_role_empty_role_rejected() {
938        let mgr = make_manager();
939        assert!(mgr.assign_role("u", "").await.is_err());
940    }
941
942    // ── remove_role ─────────────────────────────────────────────────────
943
944    #[tokio::test]
945    async fn test_remove_role_success() {
946        let mgr = make_manager();
947        mgr.create_role(Role::new("temp")).await.unwrap();
948        mgr.assign_role("u3", "temp").await.unwrap();
949        assert!(mgr.user_has_role("u3", "temp").await.unwrap());
950        mgr.remove_role("u3", "temp").await.unwrap();
951        assert!(!mgr.user_has_role("u3", "temp").await.unwrap());
952    }
953
954    #[tokio::test]
955    async fn test_remove_role_cleans_storage() {
956        let mgr = make_manager();
957        mgr.create_role(Role::new("temp")).await.unwrap();
958        mgr.assign_role("u4", "temp").await.unwrap();
959        mgr.remove_role("u4", "temp").await.unwrap();
960        let data = mgr.storage.get_kv("rbac:user_roles:u4").await.unwrap();
961        // Should be deleted when empty
962        assert!(data.is_none());
963    }
964
965    #[tokio::test]
966    async fn test_remove_role_empty_params_rejected() {
967        let mgr = make_manager();
968        assert!(mgr.remove_role("", "role").await.is_err());
969        assert!(mgr.remove_role("user", "").await.is_err());
970    }
971
972    // ── add_role_permission ─────────────────────────────────────────────
973
974    #[tokio::test]
975    async fn test_add_role_permission_success() {
976        let mgr = make_manager();
977        mgr.create_role(Role::new("admin")).await.unwrap();
978        let perm = Permission::new("write", "documents");
979        mgr.add_role_permission("admin", perm).await.unwrap();
980        let role = mgr.get_role("admin").await.unwrap();
981        assert!(
982            role.permissions
983                .iter()
984                .any(|p| p.action == "write" && p.resource == "documents")
985        );
986    }
987
988    #[tokio::test]
989    async fn test_add_role_permission_persists() {
990        let mgr = make_manager();
991        mgr.create_role(Role::new("admin2")).await.unwrap();
992        mgr.add_role_permission("admin2", Permission::new("read", "reports"))
993            .await
994            .unwrap();
995        let data = mgr
996            .storage
997            .get_kv("rbac:role:admin2")
998            .await
999            .unwrap()
1000            .unwrap();
1001        let role: Role = serde_json::from_slice(&data).unwrap();
1002        assert!(role.permissions.iter().any(|p| p.action == "read"));
1003    }
1004
1005    #[tokio::test]
1006    async fn test_add_role_permission_nonexistent_role() {
1007        let mgr = make_manager();
1008        let result = mgr
1009            .add_role_permission("ghost", Permission::new("x", "y"))
1010            .await;
1011        assert!(result.is_err());
1012    }
1013
1014    // ── set_role_inheritance ────────────────────────────────────────────
1015
1016    #[tokio::test]
1017    async fn test_set_role_inheritance_success() {
1018        let mgr = make_manager();
1019        mgr.create_role(Role::new("parent")).await.unwrap();
1020        mgr.create_role(Role::new("child")).await.unwrap();
1021        assert!(mgr.set_role_inheritance("child", "parent").await.is_ok());
1022    }
1023
1024    #[tokio::test]
1025    async fn test_set_role_inheritance_empty_names_rejected() {
1026        let mgr = make_manager();
1027        assert!(mgr.set_role_inheritance("", "parent").await.is_err());
1028        assert!(mgr.set_role_inheritance("child", "").await.is_err());
1029    }
1030
1031    // ── grant_permission / check_user_permission ────────────────────────
1032
1033    #[tokio::test]
1034    async fn test_grant_and_check_permission() {
1035        let mgr = make_manager();
1036        mgr.grant_permission("u5", "read", "files").await.unwrap();
1037        assert!(mgr.check_user_permission("u5", "read", "files").await);
1038    }
1039
1040    #[tokio::test]
1041    async fn test_check_permission_not_granted() {
1042        let mgr = make_manager();
1043        assert!(!mgr.check_user_permission("u6", "delete", "files").await);
1044    }
1045
1046    #[tokio::test]
1047    async fn test_revoke_permission() {
1048        let mgr = make_manager();
1049        mgr.grant_permission("u7", "write", "data").await.unwrap();
1050        assert!(mgr.check_user_permission("u7", "write", "data").await);
1051        mgr.revoke_permission("u7", "write", "data").await.unwrap();
1052        assert!(!mgr.check_user_permission("u7", "write", "data").await);
1053    }
1054
1055    #[tokio::test]
1056    async fn test_revoke_permission_empty_params_rejected() {
1057        let mgr = make_manager();
1058        assert!(mgr.revoke_permission("", "a", "r").await.is_err());
1059        assert!(mgr.revoke_permission("u", "", "r").await.is_err());
1060        assert!(mgr.revoke_permission("u", "a", "").await.is_err());
1061    }
1062
1063    // ── user_has_role ───────────────────────────────────────────────────
1064
1065    #[tokio::test]
1066    async fn test_user_has_role_false_when_not_assigned() {
1067        let mgr = make_manager();
1068        mgr.create_role(Role::new("r")).await.unwrap();
1069        assert!(!mgr.user_has_role("u", "r").await.unwrap());
1070    }
1071
1072    #[tokio::test]
1073    async fn test_user_has_role_empty_params_rejected() {
1074        let mgr = make_manager();
1075        assert!(mgr.user_has_role("", "r").await.is_err());
1076        assert!(mgr.user_has_role("u", "").await.is_err());
1077    }
1078
1079    // ── list_user_roles ─────────────────────────────────────────────────
1080
1081    #[tokio::test]
1082    async fn test_list_user_roles() {
1083        let mgr = make_manager();
1084        mgr.create_role(Role::new("a")).await.unwrap();
1085        mgr.create_role(Role::new("b")).await.unwrap();
1086        mgr.assign_role("u8", "a").await.unwrap();
1087        mgr.assign_role("u8", "b").await.unwrap();
1088        let roles = mgr.list_user_roles("u8").await.unwrap();
1089        assert!(roles.contains(&"a".to_string()));
1090        assert!(roles.contains(&"b".to_string()));
1091    }
1092
1093    #[tokio::test]
1094    async fn test_list_user_roles_empty_user_rejected() {
1095        let mgr = make_manager();
1096        assert!(mgr.list_user_roles("").await.is_err());
1097    }
1098
1099    // ── get_effective_permissions ────────────────────────────────────────
1100
1101    #[tokio::test]
1102    async fn test_get_effective_permissions() {
1103        let mgr = make_manager();
1104        mgr.grant_permission("u9", "read", "docs").await.unwrap();
1105        let perms = mgr.get_effective_permissions("u9").await.unwrap();
1106        assert!(!perms.is_empty());
1107    }
1108
1109    #[tokio::test]
1110    async fn test_get_effective_permissions_empty_user_rejected() {
1111        let mgr = make_manager();
1112        assert!(mgr.get_effective_permissions("").await.is_err());
1113    }
1114
1115    // ── load_persisted_roles ────────────────────────────────────────────
1116
1117    #[tokio::test]
1118    async fn test_load_persisted_roles_restores_roles() {
1119        let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
1120
1121        // Create manager, add roles and assignments, then drop it
1122        {
1123            let checker = Arc::new(RwLock::new(PermissionChecker::new()));
1124            let mgr = AuthorizationManager::new(checker, storage.clone());
1125            mgr.create_role(Role::new("restored_role")).await.unwrap();
1126            mgr.assign_role("restored_user", "restored_role")
1127                .await
1128                .unwrap();
1129        }
1130
1131        // Create fresh manager with the SAME storage, load persisted data
1132        let checker2 = Arc::new(RwLock::new(PermissionChecker::new()));
1133        let mgr2 = AuthorizationManager::new(checker2, storage);
1134        mgr2.load_persisted_roles().await.unwrap();
1135
1136        assert!(mgr2.get_role("restored_role").await.is_ok());
1137        assert!(
1138            mgr2.user_has_role("restored_user", "restored_role")
1139                .await
1140                .unwrap()
1141        );
1142    }
1143
1144    #[tokio::test]
1145    async fn test_load_persisted_roles_empty_storage_ok() {
1146        let mgr = make_manager();
1147        assert!(mgr.load_persisted_roles().await.is_ok());
1148    }
1149
1150    // ── reset_runtime_state ─────────────────────────────────────────────
1151
1152    #[tokio::test]
1153    async fn test_reset_runtime_state_clears_roles() {
1154        let mgr = make_manager();
1155        mgr.create_role(Role::new("custom")).await.unwrap();
1156        mgr.assign_role("u10", "custom").await.unwrap();
1157        mgr.reset_runtime_state().await;
1158        assert!(!mgr.user_has_role("u10", "custom").await.unwrap_or(false));
1159        // Storage should also be cleaned
1160        assert!(
1161            mgr.storage
1162                .get_kv("rbac:role:custom")
1163                .await
1164                .unwrap()
1165                .is_none()
1166        );
1167        assert!(
1168            mgr.storage
1169                .get_kv("rbac:user_roles:u10")
1170                .await
1171                .unwrap()
1172                .is_none()
1173        );
1174    }
1175
1176    // ── ABAC operations ─────────────────────────────────────────────────
1177
1178    #[tokio::test]
1179    async fn test_create_abac_policy() {
1180        let mgr = make_manager();
1181        mgr.create_abac_policy("location_gate", "Restricts by location")
1182            .await
1183            .unwrap();
1184        let data = mgr
1185            .storage
1186            .get_kv("abac:policy:location_gate")
1187            .await
1188            .unwrap();
1189        assert!(data.is_some());
1190    }
1191
1192    #[tokio::test]
1193    async fn test_create_abac_policy_empty_name_rejected() {
1194        let mgr = make_manager();
1195        assert!(mgr.create_abac_policy("", "desc").await.is_err());
1196    }
1197
1198    #[tokio::test]
1199    async fn test_create_abac_policy_empty_description_rejected() {
1200        let mgr = make_manager();
1201        assert!(mgr.create_abac_policy("name", "").await.is_err());
1202    }
1203
1204    #[tokio::test]
1205    async fn test_map_and_get_user_attribute() {
1206        let mgr = make_manager();
1207        mgr.map_user_attribute("u11", "department", "engineering")
1208            .await
1209            .unwrap();
1210        let val = mgr.get_user_attribute("u11", "department").await.unwrap();
1211        assert_eq!(val.as_deref(), Some("engineering"));
1212    }
1213
1214    #[tokio::test]
1215    async fn test_get_user_attribute_nonexistent() {
1216        let mgr = make_manager();
1217        let val = mgr.get_user_attribute("nobody", "x").await.unwrap();
1218        assert!(val.is_none());
1219    }
1220
1221    #[tokio::test]
1222    async fn test_map_user_attribute_empty_params_rejected() {
1223        let mgr = make_manager();
1224        assert!(mgr.map_user_attribute("", "a", "v").await.is_err());
1225        assert!(mgr.map_user_attribute("u", "", "v").await.is_err());
1226    }
1227
1228    #[tokio::test]
1229    async fn test_get_user_attribute_empty_params_rejected() {
1230        let mgr = make_manager();
1231        assert!(mgr.get_user_attribute("", "x").await.is_err());
1232        assert!(mgr.get_user_attribute("u", "").await.is_err());
1233    }
1234
1235    // ── check_dynamic_permission ────────────────────────────────────────
1236
1237    #[tokio::test]
1238    async fn test_check_dynamic_permission_granted() {
1239        let mgr = make_manager();
1240        mgr.grant_permission("u12", "read", "reports")
1241            .await
1242            .unwrap();
1243        let ctx = std::collections::HashMap::new();
1244        assert!(
1245            mgr.check_dynamic_permission("u12", "read", "reports", ctx)
1246                .await
1247                .unwrap()
1248        );
1249    }
1250
1251    #[tokio::test]
1252    async fn test_check_dynamic_permission_denied_no_permission() {
1253        let mgr = make_manager();
1254        let ctx = std::collections::HashMap::new();
1255        assert!(
1256            !mgr.check_dynamic_permission("u13", "read", "reports", ctx)
1257                .await
1258                .unwrap()
1259        );
1260    }
1261
1262    #[tokio::test]
1263    async fn test_check_dynamic_permission_location_mismatch() {
1264        let mgr = make_manager();
1265        mgr.grant_permission("u14", "read", "files").await.unwrap();
1266        mgr.map_user_attribute("u14", "location", "US")
1267            .await
1268            .unwrap();
1269        let mut ctx = std::collections::HashMap::new();
1270        ctx.insert("required_location".to_string(), "EU".to_string());
1271        assert!(
1272            !mgr.check_dynamic_permission("u14", "read", "files", ctx)
1273                .await
1274                .unwrap()
1275        );
1276    }
1277
1278    #[tokio::test]
1279    async fn test_check_dynamic_permission_clearance_insufficient() {
1280        let mgr = make_manager();
1281        mgr.grant_permission("u15", "read", "secret").await.unwrap();
1282        mgr.map_user_attribute("u15", "clearance_level", "2")
1283            .await
1284            .unwrap();
1285        let mut ctx = std::collections::HashMap::new();
1286        ctx.insert("required_clearance".to_string(), "5".to_string());
1287        assert!(
1288            !mgr.check_dynamic_permission("u15", "read", "secret", ctx)
1289                .await
1290                .unwrap()
1291        );
1292    }
1293
1294    #[tokio::test]
1295    async fn test_check_dynamic_permission_empty_params_rejected() {
1296        let mgr = make_manager();
1297        let ctx = std::collections::HashMap::new();
1298        assert!(
1299            mgr.check_dynamic_permission("", "r", "x", ctx.clone())
1300                .await
1301                .is_err()
1302        );
1303        assert!(
1304            mgr.check_dynamic_permission("u", "", "x", ctx.clone())
1305                .await
1306                .is_err()
1307        );
1308        assert!(
1309            mgr.check_dynamic_permission("u", "r", "", ctx)
1310                .await
1311                .is_err()
1312        );
1313    }
1314
1315    // ── create_resource ─────────────────────────────────────────────────
1316
1317    #[tokio::test]
1318    async fn test_create_resource() {
1319        let mgr = make_manager();
1320        mgr.create_resource("documents").await.unwrap();
1321        let data = mgr.storage.get_kv("resource:documents").await.unwrap();
1322        assert!(data.is_some());
1323    }
1324
1325    #[tokio::test]
1326    async fn test_create_resource_empty_name_rejected() {
1327        let mgr = make_manager();
1328        assert!(mgr.create_resource("").await.is_err());
1329    }
1330
1331    // ── delegate_permission ─────────────────────────────────────────────
1332
1333    #[tokio::test]
1334    async fn test_delegate_permission_success() {
1335        let mgr = make_manager();
1336        mgr.grant_permission("delegator", "read", "files")
1337            .await
1338            .unwrap();
1339        mgr.delegate_permission(
1340            "delegator",
1341            "delegatee",
1342            "read",
1343            "files",
1344            std::time::Duration::from_secs(3600),
1345        )
1346        .await
1347        .unwrap();
1348        let delegations = mgr.get_active_delegations("delegatee").await.unwrap();
1349        assert!(!delegations.is_empty());
1350    }
1351
1352    #[tokio::test]
1353    async fn test_delegate_permission_without_holding_it() {
1354        let mgr = make_manager();
1355        let result = mgr
1356            .delegate_permission(
1357                "delegator",
1358                "delegatee",
1359                "write",
1360                "files",
1361                std::time::Duration::from_secs(3600),
1362            )
1363            .await;
1364        assert!(result.is_err());
1365    }
1366
1367    #[tokio::test]
1368    async fn test_delegate_permission_empty_params_rejected() {
1369        let mgr = make_manager();
1370        let dur = std::time::Duration::from_secs(60);
1371        assert!(
1372            mgr.delegate_permission("", "d", "a", "r", dur)
1373                .await
1374                .is_err()
1375        );
1376        assert!(
1377            mgr.delegate_permission("d", "", "a", "r", dur)
1378                .await
1379                .is_err()
1380        );
1381        assert!(
1382            mgr.delegate_permission("d", "d2", "", "r", dur)
1383                .await
1384                .is_err()
1385        );
1386        assert!(
1387            mgr.delegate_permission("d", "d2", "a", "", dur)
1388                .await
1389                .is_err()
1390        );
1391    }
1392
1393    // ── get_active_delegations ──────────────────────────────────────────
1394
1395    #[tokio::test]
1396    async fn test_get_active_delegations_empty() {
1397        let mgr = make_manager();
1398        let delegations = mgr.get_active_delegations("nobody").await.unwrap();
1399        assert!(delegations.is_empty());
1400    }
1401
1402    #[tokio::test]
1403    async fn test_get_active_delegations_empty_user_rejected() {
1404        let mgr = make_manager();
1405        assert!(mgr.get_active_delegations("").await.is_err());
1406    }
1407
1408    // ── get_permission_metrics ──────────────────────────────────────────
1409
1410    #[tokio::test]
1411    async fn test_get_permission_metrics() {
1412        let mgr = make_manager();
1413        mgr.create_default_roles().await;
1414        mgr.create_role(Role::new("custom")).await.unwrap();
1415        let metrics = mgr.get_permission_metrics(10, 100).await.unwrap();
1416        assert!(metrics.get("total_roles").copied().unwrap_or(0) > 0);
1417        assert_eq!(metrics["active_sessions"], 10);
1418        assert_eq!(metrics["permission_checks_last_hour"], 100);
1419    }
1420
1421    // ── get_metrics ─────────────────────────────────────────────────────
1422
1423    #[tokio::test]
1424    async fn test_get_metrics() {
1425        let mgr = make_manager();
1426        mgr.create_role(Role::new("m")).await.unwrap();
1427        mgr.grant_permission("u16", "a", "r").await.unwrap();
1428        let (roles, users, perms) = mgr.get_metrics().await;
1429        assert!(roles >= 1);
1430        assert!(users >= 1);
1431        assert!(perms >= 1);
1432    }
1433}