use crate::abac::EntityLoader;
use crate::core::permission::{Decision, DecisionReason};
use crate::error::{GarrisonError, GarrisonResult};
use cedar_policy::{Authorizer, Context, EntityUid, Policy, PolicyId, PolicySet, Request, Schema};
use oxcache::traits::CacheKey;
use oxcache::Cache;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use tokio::sync::RwLock;
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct DecisionKey(String, String, String);
impl CacheKey for DecisionKey {
fn to_key_string(&self) -> String {
format!("{}\x1F{}\x1F{}", self.0, self.1, self.2)
}
}
const DECISION_CACHE_TTL_SECS: u64 = 60;
const DECISION_CACHE_MAX_CAPACITY: u64 = 10_000;
pub struct AbacEngine {
authorizer: Authorizer,
policies: Arc<RwLock<PolicySet>>,
schema: Schema,
cache: Cache<DecisionKey, Decision>,
entity_loader: Arc<dyn EntityLoader>,
}
impl AbacEngine {
pub async fn new(
schema_json: &str,
entity_loader: Arc<dyn EntityLoader>,
) -> GarrisonResult<Self> {
let schema = Schema::from_json_str(schema_json)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-schema-parse::{}", e)))?;
let cache = Cache::builder()
.ttl(Duration::from_secs(DECISION_CACHE_TTL_SECS))
.capacity(DECISION_CACHE_MAX_CAPACITY)
.build()
.await
.map_err(|e| GarrisonError::InvalidParam(format!("abac-decision-cache-init::{}", e)))?;
Ok(Self {
authorizer: Authorizer::new(),
policies: Arc::new(RwLock::new(PolicySet::new())),
schema,
cache,
entity_loader,
})
}
pub async fn evaluate(
&self,
principal: &str,
action: &str,
resource: &str,
context_json: Option<&str>,
) -> GarrisonResult<Decision> {
let cache_key = DecisionKey(
principal.to_string(),
action.to_string(),
resource.to_string(),
);
if let Some(cached) =
self.cache.get(&cache_key).await.map_err(|e| {
GarrisonError::InvalidParam(format!("abac-decision-cache-read::{}", e))
})?
{
return Ok(cached);
}
let principal_uid: EntityUid = principal
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-principal-parse::{}", e)))?;
let action_uid: EntityUid = action
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-action-parse::{}", e)))?;
let resource_uid: EntityUid = resource
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-resource-parse::{}", e)))?;
let context = match context_json {
Some(json) => Context::from_json_str(json, Some((&self.schema, &action_uid)))
.map_err(|e| GarrisonError::InvalidParam(format!("abac-context-parse::{}", e)))?,
None => Context::empty(),
};
let request = Request::new(
principal_uid,
action_uid,
resource_uid,
context,
Some(&self.schema),
)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-request-build::{}", e)))?;
let policies = self.policies.read().await;
let entities = self.entity_loader.load_entities().await?;
let response = self
.authorizer
.is_authorized(&request, &policies, &entities);
let decision = match response.decision() {
cedar_policy::Decision::Allow => Decision::allow(),
cedar_policy::Decision::Deny => Decision::deny(DecisionReason::NoMatchingPermission),
};
self.cache.set(&cache_key, &decision).await.map_err(|e| {
GarrisonError::InvalidParam(format!("abac-decision-cache-write::{}", e))
})?;
Ok(decision)
}
pub async fn load_policy(&self, policy_id: &str, policy_src: &str) -> GarrisonResult<()> {
let policy = Policy::parse(Some(PolicyId::new(policy_id)), policy_src)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-policy-parse::{}", e)))?;
let mut policies = self.policies.write().await;
policies
.add(policy)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-policy-add::{}", e)))?;
self.cache.clear().await.map_err(|e| {
GarrisonError::InvalidParam(format!("abac-decision-cache-clear::{}", e))
})?;
Ok(())
}
pub async fn unload_policy(&self, policy_id: &str) -> GarrisonResult<()> {
let policy_id = PolicyId::new(policy_id);
let mut policies = self.policies.write().await;
policies
.remove_static(policy_id)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-policy-delete::{}", e)))?;
self.cache.clear().await.map_err(|e| {
GarrisonError::InvalidParam(format!("abac-decision-cache-clear::{}", e))
})?;
Ok(())
}
pub async fn reload_all(&self, policies: HashMap<String, String>) -> GarrisonResult<()> {
let mut new_set = PolicySet::new();
for (id, src) in &policies {
let policy = Policy::parse(Some(PolicyId::new(id)), src).map_err(|e| {
GarrisonError::InvalidParam(format!("abac-cedar-policy-parse-id::{}::{}", id, e))
})?;
new_set.add(policy).map_err(|e| {
GarrisonError::InvalidParam(format!("abac-cedar-policy-add-id::{}::{}", id, e))
})?;
}
let mut guard = self.policies.write().await;
*guard = new_set;
self.cache.clear().await.map_err(|e| {
GarrisonError::InvalidParam(format!("abac-decision-cache-clear::{}", e))
})?;
Ok(())
}
pub async fn evaluate_with_temp_policy(
&self,
principal: &str,
action: &str,
resource: &str,
context_json: Option<&str>,
temp_policy_src: &str,
) -> GarrisonResult<Decision> {
let principal_uid: EntityUid = principal
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-principal-parse::{}", e)))?;
let action_uid: EntityUid = action
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-action-parse::{}", e)))?;
let resource_uid: EntityUid = resource
.parse()
.map_err(|e| GarrisonError::InvalidParam(format!("abac-resource-parse::{}", e)))?;
let context = match context_json {
Some(json) => Context::from_json_str(json, Some((&self.schema, &action_uid)))
.map_err(|e| GarrisonError::InvalidParam(format!("abac-context-parse::{}", e)))?,
None => Context::empty(),
};
let request = Request::new(
principal_uid,
action_uid,
resource_uid,
context,
Some(&self.schema),
)
.map_err(|e| GarrisonError::InvalidParam(format!("abac-cedar-request-build::{}", e)))?;
let temp_policy = Policy::parse(None, temp_policy_src).map_err(|e| {
GarrisonError::InvalidParam(format!("abac-temp-cedar-policy-parse::{}", e))
})?;
let mut temp_set = PolicySet::new();
temp_set.add(temp_policy).map_err(|e| {
GarrisonError::InvalidParam(format!("abac-temp-cedar-policy-add::{}", e))
})?;
let entities = self.entity_loader.load_entities().await?;
let response = self
.authorizer
.is_authorized(&request, &temp_set, &entities);
match response.decision() {
cedar_policy::Decision::Allow => Ok(Decision::allow()),
cedar_policy::Decision::Deny => {
Ok(Decision::deny(DecisionReason::NoMatchingPermission))
},
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::abac::{EmptyEntityLoader, StaticEntityLoader};
use cedar_policy::Entities;
async fn cache_has_entry(
engine: &AbacEngine,
principal: &str,
action: &str,
resource: &str,
) -> bool {
let key = DecisionKey(
principal.to_string(),
action.to_string(),
resource.to_string(),
);
engine.cache.get(&key).await.unwrap_or(None).is_some()
}
const SCHEMA_JSON: &str = r#"{
"": {
"entityTypes": {
"User": {
"shape": {
"type": "Record",
"attributes": {
"department": { "type": "String" }
}
}
},
"Resource": {
"shape": {
"type": "Record",
"attributes": {
"owner": { "type": "String" }
}
}
}
},
"actions": {
"access": {
"appliesTo": {
"principalTypes": ["User"],
"resourceTypes": ["Resource"]
}
}
}
}
}"#;
#[tokio::test]
async fn t121_new_from_json_schema_success() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader)).await;
assert!(engine.is_ok(), "AbacEngine::new 应成功: {:?}", engine.err());
}
#[tokio::test]
async fn t121_new_invalid_schema_returns_invalid_param() {
let result = AbacEngine::new("not a valid json", Arc::new(EmptyEntityLoader)).await;
assert!(result.is_err());
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"应为 InvalidParam"
);
}
#[tokio::test]
async fn t123_evaluate_permit_returns_allow() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy(
"p1",
r#"permit(principal == User::"alice", action == Action::"access", resource);"#,
)
.await
.expect("load policy");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(decision.allowed, "alice 应被允许");
assert_eq!(decision.reason, DecisionReason::ExplicitAllow);
}
#[tokio::test]
async fn t123_evaluate_no_match_returns_deny() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy(
"p1",
r#"permit(principal == User::"alice", action == Action::"access", resource);"#,
)
.await
.expect("load policy");
let decision = engine
.evaluate(
r#"User::"bob""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!decision.allowed, "bob 应被拒绝");
assert_eq!(decision.reason, DecisionReason::NoMatchingPermission);
}
#[tokio::test]
async fn t123_evaluate_no_policies_returns_deny() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!decision.allowed, "无策略时应默认拒绝");
}
#[tokio::test]
async fn t123_evaluate_invalid_principal_returns_error() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let result = engine
.evaluate(
"invalid",
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await;
assert!(result.is_err());
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"应为 InvalidParam"
);
}
#[tokio::test]
async fn t125_decision_mapping_allow() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load policy");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(decision.allowed);
assert_eq!(decision.reason, DecisionReason::ExplicitAllow);
}
#[tokio::test]
async fn t125_decision_mapping_deny() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!decision.allowed);
assert_eq!(decision.reason, DecisionReason::NoMatchingPermission);
}
#[tokio::test]
async fn t125_forbid_overrides_permit() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load permit");
engine
.load_policy(
"p2",
r#"forbid(principal == User::"alice", action, resource);"#,
)
.await
.expect("load forbid");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!decision.allowed, "forbid 应覆盖 permit");
}
#[tokio::test]
async fn t125_evaluate_with_context() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load policy");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
Some(r#"{}"#),
)
.await
.expect("evaluate");
assert!(decision.allowed);
}
#[tokio::test]
async fn load_policy_syntax_error_returns_invalid_param() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let result = engine
.load_policy("p1", "this is not a valid cedar policy")
.await;
assert!(result.is_err());
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"应为 InvalidParam"
);
}
#[tokio::test]
async fn unload_policy_changes_decision() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
let before = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(before.allowed, "卸载前应允许");
engine.unload_policy("p1").await.expect("unload");
let after = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!after.allowed, "卸载后应拒绝");
}
#[tokio::test]
async fn reload_all_atomically_replaces_policies() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
let mut new_policies = HashMap::new();
new_policies.insert(
"p2".to_string(),
r#"permit(principal == User::"bob", action, resource);"#.to_string(),
);
engine.reload_all(new_policies).await.expect("reload");
let alice = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!alice.allowed, "alice 应被拒绝(p1 已被替换)");
let bob = engine
.evaluate(
r#"User::"bob""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(bob.allowed, "bob 应被允许(p2 匹配)");
}
#[tokio::test]
async fn reload_all_syntax_error_keeps_existing() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
let mut bad_policies = HashMap::new();
bad_policies.insert("p2".to_string(), "invalid policy".to_string());
let result = engine.reload_all(bad_policies).await;
assert!(result.is_err(), "reload_all 应失败");
let decision = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(decision.allowed, "现有策略应保持不变");
}
#[tokio::test]
async fn concurrent_evaluate_does_not_block() {
let engine = Arc::new(
AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid"),
);
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
let mut handles = Vec::new();
for i in 0..10 {
let e = engine.clone();
handles.push(tokio::spawn(async move {
e.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
&format!(r#"Resource::"doc{i}""#),
None,
)
.await
.expect("evaluate")
}));
}
for handle in handles {
let decision = handle.await.expect("task complete");
assert!(decision.allowed, "并发求值应全部允许");
}
}
#[tokio::test]
async fn t139_evaluate_with_temp_policy_permit_returns_allow() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let temp_policy = r#"permit(principal, action == Action::"access", resource);"#;
let decision = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy,
)
.await
.expect("evaluate temp policy");
assert!(decision.allowed, "匹配的临时策略应 Allow");
}
#[tokio::test]
async fn t139_evaluate_with_temp_policy_no_match_returns_deny() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let temp_policy =
r#"permit(principal == User::"bob", action == Action::"access", resource);"#;
let decision = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy,
)
.await
.expect("evaluate temp policy");
assert!(!decision.allowed, "不匹配的临时策略应 Deny");
}
#[tokio::test]
async fn t139_evaluate_with_temp_policy_invalid_returns_error() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let result = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
"not a valid cedar policy",
)
.await;
assert!(result.is_err());
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"应为 InvalidParam"
);
}
#[tokio::test]
async fn t139_evaluate_with_temp_policy_does_not_modify_shared() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let before = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!before.allowed, "共享策略集为空时应 Deny");
let temp_policy = r#"permit(principal, action == Action::"access", resource);"#;
let temp_decision = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy,
)
.await
.expect("evaluate temp");
assert!(temp_decision.allowed, "临时策略应 Allow");
let after = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!after.allowed, "临时策略求值后共享策略集应仍为空(Deny)");
}
#[tokio::test]
async fn t139_evaluate_with_temp_policy_when_condition() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let temp_policy_true =
r#"permit(principal, action == Action::"access", resource) when { 1 == 1 };"#;
let decision_true = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy_true,
)
.await
.expect("evaluate");
assert!(decision_true.allowed, "when {{ 1 == 1 }} 应 Allow");
let temp_policy_false =
r#"permit(principal, action == Action::"access", resource) when { 1 == 2 };"#;
let decision_false = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy_false,
)
.await
.expect("evaluate");
assert!(!decision_false.allowed, "when {{ 1 == 2 }} 应 Deny");
}
#[tokio::test]
async fn t016_cache_hit_on_second_evaluate_same_key() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
let principal = r#"User::"alice""#;
let action = r#"Action::"access""#;
let resource = r#"Resource::"doc1""#;
let d1 = engine
.evaluate(principal, action, resource, None)
.await
.expect("evaluate 1");
assert!(
cache_has_entry(&engine, principal, action, resource).await,
"首次求值后缓存应包含该 key"
);
let d2 = engine
.evaluate(principal, action, resource, None)
.await
.expect("evaluate 2");
assert!(
cache_has_entry(&engine, principal, action, resource).await,
"第二次求值后缓存仍应包含该 key"
);
assert_eq!(d1.allowed, d2.allowed, "两次求值结果应一致");
}
#[tokio::test]
async fn t016_cache_miss_on_different_keys() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate 1");
engine
.evaluate(
r#"User::"bob""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate 2");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await
&& cache_has_entry(
&engine,
r#"User::"bob""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"不同 key 应分别缓存"
);
}
#[tokio::test]
async fn t016_cache_invalidated_on_unload_policy() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"求值后缓存应包含该 key"
);
engine.unload_policy("p1").await.expect("unload");
assert!(
!cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"unload 后缓存应清空"
);
let after = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate after");
assert!(!after.allowed, "unload 后应 Deny");
}
#[tokio::test]
async fn t016_cache_invalidated_on_reload_all() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"求值后缓存应包含该 key"
);
let mut new_policies = HashMap::new();
new_policies.insert(
"p2".to_string(),
r#"permit(principal == User::"bob", action, resource);"#.to_string(),
);
engine.reload_all(new_policies).await.expect("reload");
assert!(
!cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"reload 后缓存应清空"
);
let alice = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!alice.allowed, "alice 应被拒绝");
}
#[tokio::test]
async fn t016_cache_kept_on_reload_all_failure() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"求值后缓存应包含该 key"
);
let mut bad_policies = HashMap::new();
bad_policies.insert("p2".to_string(), "invalid policy".to_string());
let result = engine.reload_all(bad_policies).await;
assert!(result.is_err(), "reload_all 应失败");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"reload 失败时缓存应保持不变"
);
let alice = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(alice.allowed, "reload 失败后 alice 应仍被允许(缓存命中)");
}
#[tokio::test]
async fn t016_cache_invalidated_on_load_policy() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let before = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(!before.allowed, "无策略时应 Deny");
assert!(
cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"首次求值后缓存应包含该 key"
);
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load");
assert!(
!cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"load 后缓存应清空"
);
let after = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(after.allowed, "load 后应 Allow");
}
#[tokio::test]
async fn t016_evaluate_with_temp_policy_does_not_cache() {
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(EmptyEntityLoader))
.await
.expect("schema valid");
let temp_policy = r#"permit(principal, action == Action::"access", resource);"#;
engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
temp_policy,
)
.await
.expect("temp evaluate");
assert!(
!cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"temp policy 不应写入缓存"
);
}
const ATTR_SCHEMA_JSON: &str = r#"{
"": {
"entityTypes": {
"User": {
"shape": {
"type": "Record",
"attributes": {
"id": { "type": "String" }
}
}
},
"Resource": {
"shape": {
"type": "Record",
"attributes": {
"owner": { "type": "String" }
}
}
}
},
"actions": {
"access": {
"appliesTo": {
"principalTypes": ["User"],
"resourceTypes": ["Resource"]
}
}
}
}
}"#;
#[tokio::test]
async fn test_evaluate_with_static_entity_loader_attribute_based_policy() {
let entities_json = r#"[
{"uid": {"__entity": {"type": "User", "id": "alice"}}, "attrs": {"id": "alice"}, "parents": []},
{"uid": {"__entity": {"type": "Resource", "id": "doc1"}}, "attrs": {"owner": "alice"}, "parents": []}
]"#;
let schema = cedar_policy::Schema::from_json_str(ATTR_SCHEMA_JSON).expect("schema valid");
let entities =
Entities::from_json_str(entities_json, Some(&schema)).expect("构造带属性实体应成功");
let engine = AbacEngine::new(
ATTR_SCHEMA_JSON,
Arc::new(StaticEntityLoader::new(entities)),
)
.await
.expect("schema valid");
let policy = r#"permit(principal, action == Action::"access", resource) when { resource.owner == principal.id };"#;
engine.load_policy("p1", policy).await.expect("load policy");
let decision_allow = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(
decision_allow.allowed,
"属性匹配时应 Allow(EntityLoader 提供实体属性后应能求值基于属性的策略)"
);
let entities_mismatch_json = r#"[
{"uid": {"__entity": {"type": "User", "id": "alice"}}, "attrs": {"id": "alice"}, "parents": []},
{"uid": {"__entity": {"type": "Resource", "id": "doc1"}}, "attrs": {"owner": "bob"}, "parents": []}
]"#;
let entities_mismatch = Entities::from_json_str(entities_mismatch_json, Some(&schema))
.expect("构造不匹配实体应成功");
let engine_deny = AbacEngine::new(
ATTR_SCHEMA_JSON,
Arc::new(StaticEntityLoader::new(entities_mismatch)),
)
.await
.expect("schema valid");
engine_deny
.load_policy("p1", policy)
.await
.expect("load policy");
let decision_deny = engine_deny
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await
.expect("evaluate");
assert!(
!decision_deny.allowed,
"属性不匹配时应 Deny(owner=bob != id=alice)"
);
}
#[tokio::test]
async fn test_evaluate_with_entity_loader_error_propagates() {
struct ErrorEntityLoader;
#[async_trait::async_trait]
impl crate::abac::EntityLoader for ErrorEntityLoader {
async fn load_entities(&self) -> GarrisonResult<Entities> {
Err(GarrisonError::Config(
"EntityLoader 故意返回错误(模拟数据源不可达)".into(),
))
}
}
let engine = AbacEngine::new(SCHEMA_JSON, Arc::new(ErrorEntityLoader))
.await
.expect("schema valid");
engine
.load_policy("p1", r#"permit(principal, action, resource);"#)
.await
.expect("load policy");
let result = engine
.evaluate(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
)
.await;
assert!(
result.is_err(),
"EntityLoader 错误应通过 ? 传播,而非默认成功(规则 12:失败必须显性化)"
);
match result {
Err(GarrisonError::Config(msg)) => {
assert!(
msg.contains("EntityLoader"),
"错误消息应包含 'EntityLoader',实际: {}",
msg
);
},
Err(other) => panic!(
"期望 Config 错误(EntityLoader 错误传播),实际: {:?}",
other
),
Ok(_) => panic!("期望 Err,实际 Ok(错误被吞掉,违反规则 12)"),
}
assert!(
!cache_has_entry(
&engine,
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#
)
.await,
"EntityLoader 错误传播时缓存不应被污染"
);
let temp_result = engine
.evaluate_with_temp_policy(
r#"User::"alice""#,
r#"Action::"access""#,
r#"Resource::"doc1""#,
None,
r#"permit(principal, action, resource);"#,
)
.await;
assert!(
temp_result.is_err(),
"evaluate_with_temp_policy 也应传播 EntityLoader 错误"
);
match temp_result {
Err(GarrisonError::Config(msg)) => {
assert!(
msg.contains("EntityLoader"),
"temp policy 错误消息应包含 'EntityLoader',实际: {}",
msg
);
},
Err(other) => panic!(
"evaluate_with_temp_policy 期望 Config 错误,实际: {:?}",
other
),
Ok(_) => panic!("evaluate_with_temp_policy 期望 Err,实际 Ok"),
}
}
}