use super::mock::MockInterface;
use super::*;
use std::collections::HashMap;
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!(
matches!(result, Err(GarrisonError::InvalidParam(ref msg)) if msg.contains("core-perm-empty")),
"has_permission 空字符串应返回 InvalidParam(core-perm-empty),实际: {:?}",
result
);
}
#[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 has_role_normalizes_unicode() {
let interface = MockInterface::new().with_roles("1001", vec!["rol\u{00e9}1"]);
let interface_arc: Arc<dyn GarrisonInterface> = Arc::new(interface);
let checker = PermissionCheckerDefault::new(interface_arc);
let nfd = "role\u{0301}1";
let nfc = "rol\u{00e9}1";
assert!(
checker.has_role("1001", nfd).await.unwrap(),
"NFD 形式应规范化后匹配 NFC role"
);
assert!(
checker.has_role("1001", nfc).await.unwrap(),
"NFC 形式应直接匹配"
);
}
#[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),
}
}
#[tokio::test]
async fn mock_interface_default_methods_with_type_coverage() {
let iface = MockInterface::new();
let _ = iface
.get_permission_list_with_type("u1", "default")
.await
.unwrap();
let _ = iface
.get_role_list_with_type("u1", "default")
.await
.unwrap();
}
struct TenantScopedInterface {
by_tenant: HashMap<(i64, String), Vec<String>>,
}
#[async_trait]
impl GarrisonInterface for TenantScopedInterface {
async fn get_permission_list(&self, _login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(Vec::new())
}
async fn get_role_list(&self, _login_id: &str) -> GarrisonResult<Vec<String>> {
Ok(Vec::new())
}
async fn get_permission_list_in_tenant(
&self,
tenant_id: i64,
login_id: &str,
) -> GarrisonResult<Vec<String>> {
Ok(self
.by_tenant
.get(&(tenant_id, login_id.to_string()))
.cloned()
.unwrap_or_default())
}
}
#[tokio::test]
async fn authorize_consumes_request_tenant_id_with_tenant_scoped_source() {
let mut map = HashMap::new();
map.insert((1, "admin".to_string()), vec!["doc:delete".to_string()]);
let checker = PermissionCheckerDefault::new(Arc::new(TenantScopedInterface { by_tenant: map }));
let mut req = AuthRequest::new("admin", "doc:delete");
req.tenant_id = 1;
let decision = PermissionChecker::authorize(&checker, &req).await.unwrap();
assert!(
decision.allowed,
"租户 1 的 admin 应被允许(租户作用域数据源命中)"
);
let mut req2 = AuthRequest::new("admin", "doc:delete");
req2.tenant_id = 2;
let decision2 = PermissionChecker::authorize(&checker, &req2).await.unwrap();
assert!(
!decision2.allowed,
"租户 2 的重名 admin 不得继承租户 1 的权限"
);
assert!(
matches!(decision2.reason, DecisionReason::NoMatchingPermission),
"拒绝原因应为 NoMatchingPermission,实际: {:?}",
decision2.reason
);
}
#[tokio::test]
async fn authorize_tenant_zero_keeps_global_path_behavior() {
let interface = MockInterface::new().with_perms("1001", vec!["user:read"]);
let checker = PermissionCheckerDefault::new(Arc::new(interface));
let req = AuthRequest::new("1001", "user:read");
let decision = PermissionChecker::authorize(&checker, &req).await.unwrap();
assert!(
decision.allowed,
"tenant_id=0 应走全局数据源(行为不变契约)"
);
}
#[tokio::test]
async fn has_permission_in_tenant_default_delegates_to_global() {
let checker = make_checker();
assert!(
checker
.has_permission_in_tenant(42, "1001", "user:read")
.await
.unwrap(),
"默认实现应委托 has_permission(忽略 tenant_id)"
);
}