1use 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
11pub struct AuthorizationManager {
21 checker: Arc<RwLock<PermissionChecker>>,
22 storage: Arc<dyn AuthStorage>,
23}
24
25impl AuthorizationManager {
26 pub fn new(checker: Arc<RwLock<PermissionChecker>>, storage: Arc<dyn AuthStorage>) -> Self {
33 Self { checker, storage }
34 }
35
36 pub async fn create_default_roles(&self) {
43 let mut c = self.checker.write().await;
44 c.create_default_roles();
45 }
46
47 pub async fn load_persisted_roles(&self) -> Result<()> {
57 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 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 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 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 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 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 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 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 pub async fn list_roles(&self) -> Vec<Role> {
211 let c = self.checker.read().await;
212 c.list_roles()
213 }
214
215 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 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 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 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 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 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 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 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 #[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 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 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 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 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 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 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 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 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 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 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 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 let mut permission_granted = self.check_user_permission(user_id, action, resource).await;
599 if permission_granted {
601 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(¤t_hour) {
609 permission_granted = false;
610 debug!("Access denied: outside business hours");
611 }
612 }
613 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 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 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 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 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 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 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 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 #[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 #[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 #[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 #[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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[tokio::test]
1118 async fn test_load_persisted_roles_restores_roles() {
1119 let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
1120
1121 {
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 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 #[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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[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}