use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum DecisionReason {
ExplicitAllow,
RoleInheritedAllow,
ExplicitDeny,
NoMatchingPermission,
NoMatchingRole,
FirewallBlocked(String),
TokenInvalid,
TokenExpired,
TenantMismatch,
#[cfg(feature = "core-advanced")]
Forbid(String),
EvaluationError,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Decision {
pub allowed: bool,
pub reason: DecisionReason,
#[serde(default)]
pub errors: Vec<String>,
#[serde(default)]
pub checked_permissions: Vec<String>,
#[serde(default)]
pub matched_roles: Vec<String>,
pub trace_id: Option<String>,
}
impl Decision {
pub fn allow() -> Self {
Self {
allowed: true,
reason: DecisionReason::ExplicitAllow,
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id: None,
}
}
pub fn deny(reason: DecisionReason) -> Self {
Self {
allowed: false,
reason,
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id: None,
}
}
#[cfg(feature = "core-advanced")]
pub fn forbid(reason: impl Into<String>) -> Self {
Self {
allowed: false,
reason: DecisionReason::Forbid(reason.into()),
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id: None,
}
}
#[cfg(feature = "core-advanced")]
pub fn is_forbid(&self) -> bool {
matches!(self.reason, DecisionReason::Forbid(_))
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AuthRequest {
pub login_id: String,
pub tenant_id: i64,
pub action: String,
pub resource: Option<String>,
pub context: serde_json::Value,
}
impl AuthRequest {
pub fn new(login_id: impl Into<String>, action: impl Into<String>) -> Self {
Self {
login_id: login_id.into(),
tenant_id: 0,
action: action.into(),
resource: None,
context: serde_json::Value::Null,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::error::GarrisonResult;
#[test]
fn decision_serializes_to_json_with_required_fields() {
let decision = Decision {
allowed: true,
reason: DecisionReason::ExplicitAllow,
errors: vec![],
checked_permissions: vec!["user:read".to_string()],
matched_roles: vec!["admin".to_string()],
trace_id: Some("t-123".to_string()),
};
let json = serde_json::to_value(&decision).expect("serialize Decision");
assert_eq!(json["allowed"], serde_json::json!(true));
assert_eq!(json["reason"], serde_json::json!("explicit_allow"));
assert!(json["errors"].is_array());
assert_eq!(
json["checked_permissions"][0],
serde_json::json!("user:read")
);
assert_eq!(json["matched_roles"][0], serde_json::json!("admin"));
assert_eq!(json["trace_id"], serde_json::json!("t-123"));
}
#[test]
fn decision_deny_serializes_reason_no_matching_permission() {
let decision = Decision::deny(DecisionReason::NoMatchingPermission);
let json = serde_json::to_value(&decision).expect("serialize Decision");
assert_eq!(json["allowed"], serde_json::json!(false));
assert_eq!(json["reason"], serde_json::json!("no_matching_permission"));
}
#[test]
fn decision_reason_firewall_blocked_serializes_with_message() {
let reason = DecisionReason::FirewallBlocked("ip blocked".to_string());
let json = serde_json::to_value(&reason).expect("serialize DecisionReason");
assert_eq!(
json,
serde_json::json!({ "firewall_blocked": "ip blocked" })
);
}
#[test]
fn decision_allow_constructor_creates_explicit_allow() {
let decision = Decision::allow();
assert!(decision.allowed);
assert_eq!(decision.reason, DecisionReason::ExplicitAllow);
assert!(decision.errors.is_empty());
}
#[test]
fn auth_request_constructs_with_required_fields() {
let req = AuthRequest {
login_id: "1".to_string(),
tenant_id: 0,
action: "user:read".to_string(),
resource: None,
context: serde_json::Value::Null,
};
assert_eq!(req.login_id, "1");
assert_eq!(req.tenant_id, 0);
assert_eq!(req.action, "user:read");
assert!(req.resource.is_none());
assert!(req.context.is_null());
}
#[test]
fn auth_request_new_sets_defaults() {
let req = AuthRequest::new("1001", "user:write");
assert_eq!(req.login_id, "1001");
assert_eq!(req.tenant_id, 0);
assert_eq!(req.action, "user:write");
assert!(req.resource.is_none());
assert!(req.context.is_null());
}
#[test]
fn auth_request_with_tenant_and_resource() {
let req = AuthRequest {
login_id: "1".to_string(),
tenant_id: 42,
action: "doc:read".to_string(),
resource: Some("doc:99".to_string()),
context: serde_json::json!({"ip": "10.0.0.1"}),
};
assert_eq!(req.tenant_id, 42);
assert_eq!(req.resource.as_deref(), Some("doc:99"));
assert_eq!(req.context["ip"], serde_json::json!("10.0.0.1"));
}
#[test]
fn all_decision_reason_variants_serialize() {
let variants: &[DecisionReason] = &[
DecisionReason::ExplicitAllow,
DecisionReason::RoleInheritedAllow,
DecisionReason::ExplicitDeny,
DecisionReason::NoMatchingPermission,
DecisionReason::NoMatchingRole,
DecisionReason::FirewallBlocked("test".to_string()),
DecisionReason::TokenInvalid,
DecisionReason::TokenExpired,
DecisionReason::TenantMismatch,
];
for v in variants {
let json = serde_json::to_string(v).expect("serialize variant");
assert!(!json.is_empty(), "变体应序列化为非空 JSON: {:?}", v);
}
}
#[test]
fn garrison_result_decision_compiles() {
let ok: GarrisonResult<Decision> = Ok(Decision::allow());
assert!(ok.is_ok());
let err: GarrisonResult<Decision> = Err(crate::error::GarrisonError::NotLogin("x".into()));
assert!(err.is_err());
}
#[cfg(feature = "core-advanced")]
mod trace_id_tests {
use super::AuthRequest;
use crate::core::permission::{PermissionChecker, PermissionCheckerDefault};
use crate::error::GarrisonResult;
use crate::stp::GarrisonInterface;
use async_trait::async_trait;
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use uuid::Uuid;
struct MockInterface {
permissions: HashMap<String, Vec<String>>,
}
#[async_trait]
impl GarrisonInterface for MockInterface {
async fn get_permission_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(self.permissions.get(login_id).cloned().unwrap_or_default())
}
async fn get_role_list(&self, _login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(Vec::new())
}
}
fn make_checker() -> PermissionCheckerDefault {
let mut perms = HashMap::new();
perms.insert("1001".to_string(), vec!["user:read".to_string()]);
let interface = MockInterface { permissions: perms };
let interface_arc: Arc<dyn GarrisonInterface> = Arc::new(interface);
PermissionCheckerDefault::new(interface_arc)
}
#[tokio::test]
async fn authorize_generates_trace_id_when_decision_trace_enabled() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:read");
let decision = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize ok");
let trace_id = decision
.trace_id
.expect("decision-trace 启用时 trace_id 应为 Some");
let parsed = Uuid::parse_str(&trace_id)
.unwrap_or_else(|err| panic!("trace_id 不是合法 UUID: {trace_id} (err: {err})"));
assert_eq!(
parsed.get_version_num(),
7,
"trace_id 应为 UUID v7(时间有序),实际: {trace_id}"
);
}
#[tokio::test]
async fn authorize_trace_id_is_unique_per_request() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:read");
let d1 = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize 1");
let d2 = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize 2");
let d3 = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize 3");
let t1 = d1.trace_id.as_deref().expect("trace_id 1");
let t2 = d2.trace_id.as_deref().expect("trace_id 2");
let t3 = d3.trace_id.as_deref().expect("trace_id 3");
assert_ne!(t1, t2, "trace_id 1 与 2 不应相同");
assert_ne!(t2, t3, "trace_id 2 与 3 不应相同");
assert_ne!(t1, t3, "trace_id 1 与 3 不应相同");
}
#[tokio::test]
async fn authorize_trace_id_is_time_ordered() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:read");
let d1 = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize 1");
tokio::time::sleep(Duration::from_millis(2)).await;
let d2 = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize 2");
let t1 = d1.trace_id.as_deref().expect("trace_id 1");
let t2 = d2.trace_id.as_deref().expect("trace_id 2");
assert!(
t1 < t2,
"UUID v7 应时间有序(字典序递增):t1={t1}, t2={t2}"
);
}
}
#[cfg(feature = "core-advanced")]
mod safe_defaults_tests {
use super::*;
#[test]
fn forbid_constructor_creates_forbid_decision() {
let decision = Decision::forbid("test");
assert!(!decision.allowed, "forbid 决策 allowed 应为 false");
assert_eq!(
decision.reason,
DecisionReason::Forbid("test".to_string()),
"forbid 决策 reason 应为 Forbid(\"test\")"
);
}
#[test]
fn is_forbid_returns_true_for_forbid() {
let decision = Decision::forbid("test");
assert!(
decision.is_forbid(),
"Forbid 决策的 is_forbid() 应返回 true"
);
}
#[test]
fn is_forbid_returns_false_for_allow() {
let decision = Decision::allow();
assert!(
!decision.is_forbid(),
"Allow 决策的 is_forbid() 应返回 false"
);
}
#[test]
fn is_forbid_returns_false_for_deny() {
let decision = Decision::deny(DecisionReason::NoMatchingPermission);
assert!(
!decision.is_forbid(),
"Deny 决策的 is_forbid() 应返回 false"
);
}
#[test]
fn forbid_serializes_to_json() {
let reason = DecisionReason::Forbid("test".to_string());
let json = serde_json::to_value(&reason).expect("serialize Forbid");
assert_eq!(
json,
serde_json::json!({ "forbid": "test" }),
"Forbid(\"test\") 应序列化为 {{ \"forbid\": \"test\" }}"
);
}
#[test]
fn forbid_deserializes_from_json() {
let json = serde_json::json!({ "forbid": "test" });
let reason: DecisionReason = serde_json::from_value(json).expect("deserialize Forbid");
assert_eq!(
reason,
DecisionReason::Forbid("test".to_string()),
"{{ \"forbid\": \"test\" }} 应反序列化为 Forbid(\"test\")"
);
}
#[test]
fn forbid_partial_eq() {
let a = DecisionReason::Forbid("a".to_string());
let b = DecisionReason::Forbid("a".to_string());
assert_eq!(a, b, "Forbid(\"a\") == Forbid(\"a\") 应为 true");
}
#[test]
fn existing_allow_deny_unchanged() {
let allow = Decision::allow();
assert!(allow.allowed, "allow() 的 allowed 应为 true");
assert_eq!(
allow.reason,
DecisionReason::ExplicitAllow,
"allow() 的 reason 应为 ExplicitAllow"
);
let deny = Decision::deny(DecisionReason::NoMatchingPermission);
assert!(!deny.allowed, "deny() 的 allowed 应为 false");
assert_eq!(
deny.reason,
DecisionReason::NoMatchingPermission,
"deny() 的 reason 应为传入的 reason"
);
}
}
}