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(
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 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 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 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 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 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 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 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 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 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 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 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 let mut permission_granted = self.check_user_permission(user_id, action, resource).await;
602 if permission_granted {
604 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(¤t_hour) {
612 permission_granted = false;
613 debug!("Access denied: outside business hours");
614 }
615 }
616 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 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 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 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 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 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 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 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 #[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 #[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 #[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 #[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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[tokio::test]
1121 async fn test_load_persisted_roles_restores_roles() {
1122 let storage: Arc<dyn AuthStorage> = Arc::new(MemoryStorage::new());
1123
1124 {
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 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 #[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 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 #[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 #[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 #[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 #[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 #[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 #[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 #[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}