use super::mock::MockInterface;
use super::*;
fn make_checker() -> PermissionCheckerDefault {
let interface = MockInterface::new()
.with_perms("1001", vec!["user:read", "user:write"])
.with_roles("1001", vec!["admin", "user"]);
let interface_arc: Arc<dyn GarrisonInterface> = Arc::new(interface);
PermissionCheckerDefault::new(interface_arc)
}
#[tokio::test]
async fn has_permission_held_returns_true() {
let checker = make_checker();
assert!(checker.has_permission("1001", "user:read").await.unwrap());
}
#[tokio::test]
async fn has_permission_not_held_returns_false() {
let checker = make_checker();
assert!(!checker.has_permission("1001", "user:delete").await.unwrap());
}
#[tokio::test]
async fn has_permission_empty_string_returns_error() {
let checker = make_checker();
let result = checker.has_permission("1001", "").await;
assert!(result.is_err());
}
#[tokio::test]
async fn has_role_held_returns_true() {
let checker = make_checker();
assert!(checker.has_role("1001", "admin").await.unwrap());
}
#[tokio::test]
async fn has_role_not_held_returns_false() {
let checker = make_checker();
assert!(!checker.has_role("1001", "superadmin").await.unwrap());
}
#[tokio::test]
async fn check_permission_held_returns_ok() {
let checker = make_checker();
assert!(checker.check_permission("1001", "user:read").await.is_ok());
}
#[tokio::test]
async fn check_permission_not_held_returns_error() {
let checker = make_checker();
let result = checker.check_permission("1001", "user:delete").await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::NotPermission(_)) => {},
other => panic!("期望 NotPermission,实际: {:?}", other),
}
}
#[tokio::test]
async fn check_role_held_returns_ok() {
let checker = make_checker();
assert!(checker.check_role("1001", "admin").await.is_ok());
}
#[tokio::test]
async fn check_role_not_held_returns_error() {
let checker = make_checker();
let result = checker.check_role("1001", "superadmin").await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::NotRole(_)) => {},
other => panic!("期望 NotRole,实际: {:?}", other),
}
}
#[tokio::test]
async fn has_any_permission_any_match_returns_true() {
let checker = make_checker();
assert!(
checker
.has_any_permission("1001", &["user:read", "user:delete"])
.await
);
}
#[tokio::test]
async fn has_any_permission_no_match_returns_false() {
let checker = make_checker();
assert!(
!checker
.has_any_permission("1001", &["user:delete", "user:create"])
.await
);
}
#[tokio::test]
async fn has_all_permissions_all_match_returns_true() {
let checker = make_checker();
assert!(
checker
.has_all_permissions("1001", &["user:read", "user:write"])
.await
);
}
#[tokio::test]
async fn has_all_permissions_partial_match_returns_false() {
let checker = make_checker();
assert!(
!checker
.has_all_permissions("1001", &["user:read", "user:delete"])
.await
);
}
#[tokio::test]
async fn has_all_permissions_empty_list_returns_true() {
let checker = make_checker();
assert!(checker.has_all_permissions("1001", &[]).await);
}
#[tokio::test]
async fn authorize_returns_decision_with_allowed_true_when_permission_matches() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:read");
let decision = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize ok");
assert!(decision.allowed);
assert_eq!(decision.reason, DecisionReason::ExplicitAllow);
}
#[tokio::test]
async fn authorize_returns_deny_when_permission_not_matched() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:delete");
let decision = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize ok");
assert!(!decision.allowed);
assert_eq!(decision.reason, DecisionReason::NoMatchingPermission);
}
#[tokio::test]
async fn authorize_returns_error_for_empty_permission() {
let checker = make_checker();
let request = AuthRequest::new("1001", "");
let result = PermissionChecker::authorize(&checker, &request).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidParam(_)) => {},
other => panic!("期望 InvalidParam,实际: {:?}", other),
}
}
#[tokio::test]
async fn check_permission_delegates_to_authorize_and_returns_allowed() {
let checker = make_checker();
let req_ok = AuthRequest::new("1001", "user:read");
let decision_ok = PermissionChecker::authorize(&checker, &req_ok)
.await
.expect("authorize ok");
assert!(decision_ok.allowed);
assert!(checker.check_permission("1001", "user:read").await.is_ok());
let req_no = AuthRequest::new("1001", "user:delete");
let decision_no = PermissionChecker::authorize(&checker, &req_no)
.await
.expect("authorize ok");
assert!(!decision_no.allowed);
assert!(checker
.check_permission("1001", "user:delete")
.await
.is_err());
}
#[tokio::test]
async fn check_permission_deny_returns_not_permission_error() {
let checker = make_checker();
let result = checker.check_permission("1001", "user:delete").await;
match result.err() {
Some(GarrisonError::NotPermission(msg)) => {
assert!(msg.contains("1001"), "错误消息应含 login_id");
assert!(msg.contains("user:delete"), "错误消息应含 permission");
},
other => panic!("期望 NotPermission,实际: {:?}", other),
}
}
#[tokio::test]
async fn check_role_still_returns_not_role_when_unmatched() {
let checker = make_checker();
let result = checker.check_role("1001", "superadmin").await;
match result.err() {
Some(GarrisonError::NotRole(_)) => {},
other => panic!("期望 NotRole,实际: {:?}", other),
}
}
#[tokio::test]
async fn authorize_decision_serializes_to_json() {
let checker = make_checker();
let request = AuthRequest::new("1001", "user:read");
let decision = PermissionChecker::authorize(&checker, &request)
.await
.expect("authorize ok");
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"));
}
#[tokio::test]
async fn check_permission_normalizes_unicode() {
let interface = MockInterface::new().with_perms("1001", vec!["user:\u{00e9}read"]);
let interface_arc: Arc<dyn GarrisonInterface> = Arc::new(interface);
let checker = PermissionCheckerDefault::new(interface_arc);
let nfd = "user:e\u{0301}read";
let nfc = "user:\u{00e9}read";
assert!(
checker.check_permission("1001", nfd).await.is_ok(),
"NFD 形式应规范化后匹配 NFC permission"
);
assert!(
checker.check_permission("1001", nfc).await.is_ok(),
"NFC 形式应直接匹配"
);
}
#[tokio::test]
async fn check_permission_rejects_over_256_bytes() {
let long_perm = "x".repeat(300); let checker = make_checker();
let result = checker.check_permission("1001", &long_perm).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"超长 permission 应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
async fn has_role_empty_string_returns_error() {
let checker = make_checker();
let result = checker.has_role("1001", "").await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(ref msg)) if msg.contains("core-role-empty")),
"has_role 空字符串应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_role_deny_message_includes_login_id_and_role() {
let checker = make_checker();
let result = checker.check_role("1001", "superadmin").await;
match result.err() {
Some(GarrisonError::NotRole(msg)) => {
assert!(msg.contains("1001"), "错误消息应含 login_id,实际: {}", msg);
assert!(
msg.contains("superadmin"),
"错误消息应含 role,实际: {}",
msg
);
},
other => panic!("期望 NotRole,实际: {:?}", other),
}
}