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