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