use super::{PermissionError, Principal, PrincipalRequirement};
use crate::result::{ClassifyError, ErrorKind};
#[tokio::test]
async fn permission_checker_receives_validated_requests_and_maps_denials() {
use super::{PermissionChecker, PermissionDecision, PermissionRequest};
struct Checker;
#[async_trait::async_trait]
impl PermissionChecker for Checker {
async fn check(
&self,
_: &Principal,
request: &PermissionRequest,
) -> Result<PermissionDecision, PermissionError> {
Ok(
if request.action() == "read" && request.resource() == "users" {
PermissionDecision::Allow
} else {
PermissionDecision::Deny
},
)
}
}
let principal = test_user();
assert!(
Checker
.ensure_allowed(
&principal,
&PermissionRequest::new(" read ", " users ").unwrap()
)
.await
.is_ok()
);
assert!(matches!(
Checker
.ensure_allowed(
&principal,
&PermissionRequest::new("delete", "users").unwrap()
)
.await,
Err(PermissionError::Denied)
));
}
fn test_user() -> Principal {
Principal::user("usr_1").expect("static test principal id is valid")
}
#[test]
fn supports_wildcard_scopes() {
let principal = test_user()
.with_scopes(["user:*"])
.expect("static test scope is valid");
assert!(principal.has_scope("user:read"));
assert!(principal.has_scope("user:write"));
assert!(!principal.has_scope("client:read"));
}
#[test]
fn role_guard_requires_matching_role() {
let principal = test_user()
.with_roles(["admin"])
.expect("static test role is valid");
assert!(
PrincipalRequirement::role("admin")
.expect("static guard role is valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::role("operator")
.expect("static guard role is valid")
.check(&principal)
.is_err()
);
}
#[test]
fn scope_guard_supports_wildcard_scopes() {
let principal = test_user()
.with_scopes(["user:*"])
.expect("static test scope is valid");
assert!(
PrincipalRequirement::scope("user:read")
.expect("static guard scope is valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::scope("client:read")
.expect("static guard scope is valid")
.check(&principal)
.is_err()
);
}
#[test]
fn role_set_guard_allows_any_matching_role() {
let principal = test_user()
.with_roles(["operator"])
.expect("static test role is valid");
assert!(
PrincipalRequirement::any_roles(["admin", "operator"])
.expect("static guard roles are valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::any_roles(["admin"])
.expect("static guard role is valid")
.check(&principal)
.is_err()
);
}
#[test]
fn role_set_guard_can_require_all_roles() {
let principal = test_user()
.with_roles(["admin", "operator"])
.expect("static test roles are valid");
assert!(
PrincipalRequirement::all_roles(["admin", "operator"])
.expect("static guard roles are valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::all_roles(["admin", "auditor"])
.expect("static guard roles are valid")
.check(&principal)
.is_err()
);
}
#[test]
fn scope_set_guard_requires_all_scopes() {
let principal = test_user()
.with_scopes(["user:*", "audit:read"])
.expect("static test scopes are valid");
assert!(
PrincipalRequirement::all_scopes(["user:read", "audit:read"])
.expect("static guard scopes are valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::all_scopes(["user:read", "client:read"])
.expect("static guard scopes are valid")
.check(&principal)
.is_err()
);
}
#[test]
fn scope_set_guard_can_allow_any_scope() {
let principal = test_user()
.with_scopes(["user:*"])
.expect("static test scope is valid");
assert!(
PrincipalRequirement::any_scopes(["client:read", "user:read"])
.expect("static guard scopes are valid")
.check(&principal)
.is_ok()
);
assert!(
PrincipalRequirement::any_scopes(["client:read", "audit:read"])
.expect("static guard scopes are valid")
.check(&principal)
.is_err()
);
}
#[test]
fn empty_permission_guards_are_invalid_policies() {
assert!(matches!(
PrincipalRequirement::role(""),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
PrincipalRequirement::scope(""),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
PrincipalRequirement::any_roles(std::iter::empty::<&str>()),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
PrincipalRequirement::all_roles(std::iter::empty::<&str>()),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
PrincipalRequirement::any_scopes(std::iter::empty::<&str>()),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
PrincipalRequirement::all_scopes(std::iter::empty::<&str>()),
Err(PermissionError::InvalidPolicy(_))
));
}
#[test]
fn permission_request_rejects_empty_parts() {
assert!(matches!(
super::PermissionRequest::new("", "users"),
Err(PermissionError::InvalidPolicy(_))
));
assert!(matches!(
super::PermissionRequest::new("read", ""),
Err(PermissionError::InvalidPolicy(_))
));
let request = super::PermissionRequest::new("read", "users").expect("request should be valid");
assert_eq!(request.action(), "read");
assert_eq!(request.resource(), "users");
let invalid = serde_json::json!({
"action": "",
"resource": "users"
});
assert!(serde_json::from_value::<super::PermissionRequest>(invalid).is_err());
}
#[test]
fn principal_deduplicates_roles_and_scopes() {
let mut principal = test_user()
.with_roles(["admin", " admin "])
.expect("static test roles are valid")
.with_scopes(["user:read", " user:read "])
.expect("static test scopes are valid");
principal
.add_role(" admin ")
.expect("static test role is valid");
principal
.add_scope(" user:read ")
.expect("static test scope is valid");
assert_eq!(principal.id(), "usr_1");
assert_eq!(principal.kind(), super::PrincipalKind::User);
assert_eq!(principal.roles(), ["admin"]);
assert_eq!(principal.scopes(), ["user:read"]);
}
#[test]
fn principal_debug_redacts_identifiers_and_authorities_without_changing_wire_data() {
let id = "private-principal-id";
let tenant_id = "private-tenant-id";
let role = "private-role";
let scope = "private:scope";
let principal = Principal::user(id)
.expect("principal should be valid")
.with_tenant_id(tenant_id)
.expect("tenant should be valid")
.with_roles([role])
.expect("role should be valid")
.with_scopes([scope])
.expect("scope should be valid");
let debug = format!("{principal:?}");
assert!(debug.contains("[REDACTED]"));
for sensitive in [id, tenant_id, role, scope] {
assert!(!debug.contains(sensitive));
}
let wire = serde_json::to_value(principal).expect("principal should serialize");
assert_eq!(wire["id"], id);
assert_eq!(wire["tenant_id"], tenant_id);
assert_eq!(wire["roles"][0], role);
assert_eq!(wire["scopes"][0], scope);
}
#[test]
fn principal_rejects_invalid_identifiers_and_authorities() {
assert!(matches!(
Principal::user(""),
Err(PermissionError::InvalidPrincipal(_))
));
assert!(matches!(
Principal::client("client with space"),
Err(PermissionError::InvalidPrincipal(_))
));
assert!(matches!(
test_user().with_roles([""]),
Err(PermissionError::InvalidAuthority(_))
));
assert!(matches!(
test_user().with_scopes(["user read"]),
Err(PermissionError::InvalidAuthority(_))
));
}
#[test]
fn principal_deserialization_uses_same_validation() {
let valid = serde_json::json!({
"id": "usr_1",
"kind": "user",
"roles": ["admin", " admin "],
"scopes": ["user:*"]
});
let principal: Principal =
serde_json::from_value(valid).expect("valid principal JSON should deserialize");
assert_eq!(principal.roles(), ["admin"]);
assert!(principal.has_scope("user:read"));
let invalid = serde_json::json!({
"id": "usr_1",
"kind": "user",
"roles": [""]
});
assert!(serde_json::from_value::<Principal>(invalid).is_err());
}
#[test]
fn blank_role_or_scope_checks_are_not_satisfied_by_wildcards() {
let principal = test_user()
.with_roles(["admin"])
.expect("static test role is valid")
.with_scopes(["*"])
.expect("static test scope is valid");
assert!(!principal.has_role(" "));
assert!(!principal.has_scope(" "));
assert!(!principal.has_all_roles(std::iter::empty::<&str>()));
assert!(!principal.has_all_scopes(std::iter::empty::<&str>()));
}
#[test]
fn principal_can_remove_authorities() {
let mut principal = test_user()
.with_roles(["admin", "operator"])
.expect("static test roles are valid")
.with_scopes(["user:read", "audit:read"])
.expect("static test scopes are valid");
assert!(principal.remove_role(" operator "));
assert!(principal.remove_scope(" audit:read "));
assert!(!principal.remove_role("missing"));
assert_eq!(principal.roles(), ["admin"]);
assert_eq!(principal.scopes(), ["user:read"]);
}
#[test]
fn permission_errors_have_stable_classification() {
let denied = PermissionError::Denied.error_descriptor();
let unavailable = PermissionError::Unavailable.error_descriptor();
let invalid_principal =
PermissionError::InvalidPrincipal("empty id".to_owned()).error_descriptor();
let invalid = PermissionError::InvalidPolicy("empty scope".to_owned()).error_descriptor();
assert_eq!(denied.kind(), ErrorKind::Authorization);
assert_eq!(denied.code().as_str(), "permission_denied");
assert_eq!(unavailable.kind(), ErrorKind::Unavailable);
assert!(unavailable.retryable());
assert_eq!(invalid_principal.kind(), ErrorKind::Validation);
assert_eq!(invalid_principal.code().as_str(), "principal_invalid");
assert_eq!(invalid.kind(), ErrorKind::Internal);
assert_eq!(invalid.code().as_str(), "permission_invalid_policy");
}