use super::GarrisonLogicDefault;
#[cfg(not(feature = "tenant-isolation"))]
#[allow(deprecated)]
use crate::context::tenant::current_tenant_id;
#[cfg(feature = "tenant-isolation")]
use crate::context::tenant::current_tenant_id_or_error;
use crate::core::permission::AuthRequest;
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(feature = "listener")]
use crate::listener::GarrisonEvent;
use crate::stp::session::SessionLogic;
use async_trait::async_trait;
#[async_trait]
pub trait PermissionLogic: SessionLogic {
async fn check_permission(&self, permission: &str) -> GarrisonResult<()>;
async fn check_role(&self, role: &str) -> GarrisonResult<()>;
async fn has_permission(&self, permission: &str) -> GarrisonResult<bool> {
match self.check_permission(permission).await {
Ok(()) => Ok(true),
Err(GarrisonError::NotPermission(_)) => Ok(false),
Err(GarrisonError::NotLogin(_)) => Ok(false),
Err(e) => Err(e),
}
}
async fn has_role(&self, role: &str) -> GarrisonResult<bool> {
match self.check_role(role).await {
Ok(()) => Ok(true),
Err(GarrisonError::NotRole(_)) => Ok(false),
Err(GarrisonError::NotLogin(_)) => Ok(false),
Err(e) => Err(e),
}
}
async fn get_permission_list(&self) -> GarrisonResult<Vec<String>> {
Err(GarrisonError::NotImplemented(
"get_permission_list 未实现(默认实现,需在 GarrisonLogicDefault 或业务实现中覆写)"
.to_string(),
))
}
async fn get_role_list(&self) -> GarrisonResult<Vec<String>> {
Err(GarrisonError::NotImplemented(
"get_role_list 未实现(默认实现,需在 GarrisonLogicDefault 或业务实现中覆写)"
.to_string(),
))
}
}
#[async_trait]
impl PermissionLogic for GarrisonLogicDefault {
async fn check_permission(&self, permission: &str) -> GarrisonResult<()> {
let login_id = match self.get_login_id().await? {
Some(id) => id,
None => {
#[cfg(feature = "metrics-prometheus")]
if let Some(m) = &self.metrics {
m.record_permission_query(false);
}
return if self.config.throw_on_not_login {
Err(GarrisonError::NotLogin("stp-not-login::".to_string()))
} else {
Err(GarrisonError::NotPermission(permission.to_string()))
};
},
};
if let Some(pc) = &self.permission_checker {
#[cfg(not(feature = "tenant-isolation"))]
#[allow(deprecated)]
let tenant_id = current_tenant_id();
#[cfg(feature = "tenant-isolation")]
let tenant_id = current_tenant_id_or_error()?;
let request = AuthRequest {
login_id: login_id.clone(),
tenant_id,
action: permission.to_string(),
resource: None,
context: serde_json::Value::Null,
};
let decision = pc.authorize(&request).await?;
#[cfg(feature = "listener")]
if let Some(lm) = &self.listener_manager {
lm.broadcast(&GarrisonEvent::PermissionCheck {
login_id,
permission: permission.to_string(),
request_context: None,
})
.await;
}
#[cfg(feature = "metrics-prometheus")]
if let Some(m) = &self.metrics {
m.record_permission_query(decision.allowed);
}
return if decision.allowed {
Ok(())
} else {
Err(GarrisonError::NotPermission(permission.to_string()))
};
}
#[cfg(not(feature = "tenant-isolation"))]
#[allow(deprecated)]
let _tenant_id = current_tenant_id();
#[cfg(feature = "tenant-isolation")]
let _tenant_id = current_tenant_id_or_error()?;
let has_perm = self
.firewall
.check_permission(&login_id, permission)
.await?;
#[cfg(feature = "metrics-prometheus")]
if let Some(m) = &self.metrics {
m.record_permission_query(has_perm);
}
if has_perm {
Ok(())
} else {
Err(GarrisonError::NotPermission(permission.to_string()))
}
}
async fn check_role(&self, role: &str) -> GarrisonResult<()> {
let login_id = match self.get_login_id().await? {
Some(id) => id,
None => {
#[cfg(feature = "metrics-prometheus")]
if let Some(m) = &self.metrics {
m.record_role_query(false);
}
return if self.config.throw_on_not_login {
Err(GarrisonError::NotLogin("stp-not-login::".to_string()))
} else {
Err(GarrisonError::NotRole(role.to_string()))
};
},
};
let has_role = self.firewall.check_role(&login_id, role).await?;
#[cfg(feature = "metrics-prometheus")]
if let Some(m) = &self.metrics {
m.record_role_query(has_role);
}
if has_role {
Ok(())
} else {
Err(GarrisonError::NotRole(role.to_string()))
}
}
async fn get_permission_list(&self) -> GarrisonResult<Vec<String>> {
let login_id = match self.get_login_id().await? {
Some(id) => id,
None => return Ok(vec![]),
};
self.firewall.get_permission_list(&login_id).await
}
async fn get_role_list(&self) -> GarrisonResult<Vec<String>> {
let login_id = match self.get_login_id().await? {
Some(id) => id,
None => return Ok(vec![]),
};
self.firewall.get_role_list(&login_id).await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GarrisonConfig;
use crate::error::GarrisonResult;
use crate::stp::core::GarrisonCore;
use crate::stp::session::SessionLogic;
use std::sync::Arc;
struct MockPermission {
config: Arc<GarrisonConfig>,
has_permission: bool,
}
impl GarrisonCore for MockPermission {
fn config(&self) -> Arc<GarrisonConfig> {
Arc::clone(&self.config)
}
}
#[async_trait]
impl SessionLogic for MockPermission {
async fn login(
&self,
_login_id: &str,
_params: &crate::stp::LoginParams,
) -> GarrisonResult<String> {
Ok("mock-token".to_string())
}
async fn login_with_token(&self, _login_id: &str, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn logout(&self) -> GarrisonResult<()> {
Ok(())
}
async fn logout_by_login_id(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout_by_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn revoke_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_login(&self) -> GarrisonResult<bool> {
Ok(true)
}
async fn get_login_id(&self) -> GarrisonResult<Option<String>> {
Ok(Some("42".to_string()))
}
}
#[async_trait]
impl PermissionLogic for MockPermission {
async fn check_permission(&self, _permission: &str) -> GarrisonResult<()> {
if self.has_permission {
Ok(())
} else {
Err(crate::error::GarrisonError::NotPermission(
"mock: not permission".to_string(),
))
}
}
async fn check_role(&self, _role: &str) -> GarrisonResult<()> {
Ok(())
}
}
#[tokio::test]
async fn check_permission_grants_when_has() {
let mock = MockPermission {
config: Arc::new(GarrisonConfig::default()),
has_permission: true,
};
mock.check_permission("user:read").await.unwrap();
}
#[tokio::test]
async fn check_permission_denies_when_not_has() {
let mock = MockPermission {
config: Arc::new(GarrisonConfig::default()),
has_permission: false,
};
let result = mock.check_permission("user:read").await;
assert!(matches!(
result,
Err(crate::error::GarrisonError::NotPermission(_))
));
}
struct MockPermissionHas {
config: Arc<GarrisonConfig>,
perm_result: GarrisonResult<()>,
role_result: GarrisonResult<()>,
}
impl GarrisonCore for MockPermissionHas {
fn config(&self) -> Arc<GarrisonConfig> {
Arc::clone(&self.config)
}
}
#[async_trait]
impl SessionLogic for MockPermissionHas {
async fn login(
&self,
_login_id: &str,
_params: &crate::stp::LoginParams,
) -> GarrisonResult<String> {
Ok("mock-token".to_string())
}
async fn login_with_token(&self, _login_id: &str, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn logout(&self) -> GarrisonResult<()> {
Ok(())
}
async fn logout_by_login_id(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout_by_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn revoke_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_login(&self) -> GarrisonResult<bool> {
Ok(true)
}
async fn get_login_id(&self) -> GarrisonResult<Option<String>> {
Ok(Some("42".to_string()))
}
}
#[async_trait]
impl PermissionLogic for MockPermissionHas {
async fn check_permission(&self, _permission: &str) -> GarrisonResult<()> {
match &self.perm_result {
Ok(()) => Ok(()),
Err(crate::error::GarrisonError::NotPermission(s)) => {
Err(crate::error::GarrisonError::NotPermission(s.clone()))
},
Err(crate::error::GarrisonError::NotLogin(s)) => {
Err(crate::error::GarrisonError::NotLogin(s.clone()))
},
Err(crate::error::GarrisonError::Dao(s)) => {
Err(crate::error::GarrisonError::Dao(s.clone()))
},
Err(e) => panic!("MockPermissionHas 不支持此错误变体: {:?}", e),
}
}
async fn check_role(&self, _role: &str) -> GarrisonResult<()> {
match &self.role_result {
Ok(()) => Ok(()),
Err(crate::error::GarrisonError::NotRole(s)) => {
Err(crate::error::GarrisonError::NotRole(s.clone()))
},
Err(crate::error::GarrisonError::NotLogin(s)) => {
Err(crate::error::GarrisonError::NotLogin(s.clone()))
},
Err(crate::error::GarrisonError::Dao(s)) => {
Err(crate::error::GarrisonError::Dao(s.clone()))
},
Err(e) => panic!("MockPermissionHas 不支持此错误变体: {:?}", e),
}
}
}
fn ok_perm_mock() -> MockPermissionHas {
MockPermissionHas {
config: Arc::new(GarrisonConfig::default()),
perm_result: Ok(()),
role_result: Ok(()),
}
}
#[tokio::test]
async fn has_permission_returns_true_when_check_ok() {
let mock = ok_perm_mock();
assert!(mock.has_permission("user:read").await.unwrap());
}
#[tokio::test]
async fn has_permission_returns_false_when_not_permission() {
let mut mock = ok_perm_mock();
mock.perm_result = Err(GarrisonError::NotPermission("user:read".to_string()));
assert!(!mock.has_permission("user:read").await.unwrap());
}
#[tokio::test]
async fn has_permission_returns_false_when_not_login() {
let mut mock = ok_perm_mock();
mock.perm_result = Err(GarrisonError::NotLogin("未登录".to_string()));
assert!(!mock.has_permission("user:read").await.unwrap());
}
#[tokio::test]
async fn has_permission_propagates_dao_error() {
let mut mock = ok_perm_mock();
mock.perm_result = Err(GarrisonError::Dao("连接失败".to_string()));
let result = mock.has_permission("user:read").await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref s)) if s.contains("连接失败")),
"Dao 错误应透传,实际: {:?}",
result
);
}
#[tokio::test]
async fn has_role_returns_true_when_check_ok() {
let mock = ok_perm_mock();
assert!(mock.has_role("admin").await.unwrap());
}
#[tokio::test]
async fn has_role_returns_false_when_not_role() {
let mut mock = ok_perm_mock();
mock.role_result = Err(GarrisonError::NotRole("admin".to_string()));
assert!(!mock.has_role("admin").await.unwrap());
}
#[tokio::test]
async fn has_role_returns_false_when_not_login() {
let mut mock = ok_perm_mock();
mock.role_result = Err(GarrisonError::NotLogin("未登录".to_string()));
assert!(!mock.has_role("admin").await.unwrap());
}
#[tokio::test]
async fn has_role_propagates_dao_error() {
let mut mock = ok_perm_mock();
mock.role_result = Err(GarrisonError::Dao("连接失败".to_string()));
let result = mock.has_role("admin").await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref s)) if s.contains("连接失败")),
"Dao 错误应透传,实际: {:?}",
result
);
}
#[tokio::test]
async fn has_permission_true_when_mock_field_true() {
let mock = MockPermission {
config: Arc::new(GarrisonConfig::default()),
has_permission: true,
};
assert!(mock.has_permission("user:read").await.unwrap());
}
#[tokio::test]
async fn has_permission_false_when_mock_field_false() {
let mock = MockPermission {
config: Arc::new(GarrisonConfig::default()),
has_permission: false,
};
assert!(!mock.has_permission("user:read").await.unwrap());
}
#[tokio::test]
async fn get_permission_list_default_returns_not_implemented() {
let mock = ok_perm_mock();
let result = mock.get_permission_list().await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(ref s)) if s.contains("get_permission_list")),
"默认实现应返回 NotImplemented,实际: {:?}",
result
);
}
#[tokio::test]
async fn get_role_list_default_returns_not_implemented() {
let mock = ok_perm_mock();
let result = mock.get_role_list().await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(ref s)) if s.contains("get_role_list")),
"默认实现应返回 NotImplemented,实际: {:?}",
result
);
}
mod default_impl_coverage {
use super::*;
use crate::context::tenant::with_default_tenant;
use crate::dao::GarrisonDao;
use crate::session::GarrisonSession;
use crate::stp::mock::{MockDao, MockFirewall};
use crate::stp::with_current_token;
use crate::strategy::GarrisonPermissionStrategy;
use std::sync::Arc;
fn make_logic(
throw_on_not_login: bool,
has_permission: bool,
has_role: bool,
) -> GarrisonLogicDefault {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = throw_on_not_login;
config.token_style = "uuid".to_string();
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(MockFirewall {
has_permission,
has_role,
});
GarrisonLogicDefault::new(session, Arc::new(config), firewall)
}
#[tokio::test]
async fn check_permission_no_login_throws_not_login() {
let logic = make_logic(true, true, true);
let result = logic.check_permission("user:read").await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"未登录 + throw=true 应返回 NotLogin,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_permission_no_login_returns_not_permission() {
let logic = make_logic(false, true, true);
let result = logic.check_permission("user:read").await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"未登录 + throw=false 应返回 NotPermission,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_permission_logged_in_with_perm_returns_ok() {
let logic = make_logic(false, true, true);
let token = logic
.login("perm-user-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.check_permission("user:read").await }).await
})
.await;
assert!(
result.is_ok(),
"已登录 + has_permission=true 应返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_permission_logged_in_without_perm_returns_not_permission() {
let logic = make_logic(false, false, true);
let token = logic
.login("perm-user-002", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.check_permission("user:read").await }).await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"已登录 + has_permission=false 应返回 NotPermission,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_role_no_login_throws_not_login() {
let logic = make_logic(true, true, true);
let result = logic.check_role("admin").await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(_))),
"未登录 + throw=true 应返回 NotLogin,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_role_no_login_returns_not_role() {
let logic = make_logic(false, true, true);
let result = logic.check_role("admin").await;
assert!(
matches!(result, Err(GarrisonError::NotRole(_))),
"未登录 + throw=false 应返回 NotRole,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_role_logged_in_with_role_returns_ok() {
let logic = make_logic(false, true, true);
let token = logic
.login("role-user-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.check_role("admin").await }).await;
assert!(
result.is_ok(),
"已登录 + has_role=true 应返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_role_logged_in_without_role_returns_not_role() {
let logic = make_logic(false, true, false);
let token = logic
.login("role-user-002", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.check_role("admin").await }).await;
assert!(
matches!(result, Err(GarrisonError::NotRole(_))),
"已登录 + has_role=false 应返回 NotRole,实际: {:?}",
result
);
}
#[tokio::test]
async fn get_permission_list_no_login_returns_empty() {
let logic = make_logic(false, true, true);
let result = logic.get_permission_list().await;
assert!(result.is_ok(), "未登录应返回 Ok,实际: {:?}", result);
assert!(result.unwrap().is_empty(), "未登录应返回空 Vec");
}
#[tokio::test]
async fn get_role_list_no_login_returns_empty() {
let logic = make_logic(false, true, true);
let result = logic.get_role_list().await;
assert!(result.is_ok(), "未登录应返回 Ok,实际: {:?}", result);
assert!(result.unwrap().is_empty(), "未登录应返回空 Vec");
}
#[tokio::test]
async fn get_permission_list_logged_in_delegates_to_firewall() {
let logic = make_logic(false, true, true);
let token = logic
.login("list-user-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result =
with_current_token(token, async { logic.get_permission_list().await }).await;
assert!(result.is_ok(), "已登录应返回 Ok,实际: {:?}", result);
}
#[tokio::test]
async fn get_role_list_logged_in_delegates_to_firewall() {
let logic = make_logic(false, true, true);
let token = logic
.login("list-user-002", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.get_role_list().await }).await;
assert!(result.is_ok(), "已登录应返回 Ok,实际: {:?}", result);
}
#[tokio::test]
async fn has_permission_logged_in_with_perm_returns_true() {
let logic = make_logic(false, true, true);
let token = logic
.login("has-perm-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.has_permission("user:read").await }).await
})
.await;
assert!(result.is_ok(), "应返回 Ok,实际: {:?}", result);
assert!(result.unwrap(), "has_permission=true 应返回 true");
}
#[tokio::test]
async fn has_role_logged_in_without_role_returns_false() {
let logic = make_logic(false, true, false);
let token = logic
.login("has-role-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async { logic.has_role("admin").await }).await;
assert!(result.is_ok(), "应返回 Ok,实际: {:?}", result);
assert!(!result.unwrap(), "has_role=false 应返回 false");
}
}
mod permission_checker_coverage {
use super::*;
use crate::context::tenant::with_default_tenant;
use crate::core::permission::{AuthRequest, Decision, DecisionReason, PermissionChecker};
use crate::dao::GarrisonDao;
use crate::session::GarrisonSession;
use crate::stp::mock::{MockDao, MockFirewall};
use crate::stp::with_current_token;
use crate::strategy::GarrisonPermissionStrategy;
use async_trait::async_trait;
use std::sync::Arc;
struct MockPermissionChecker {
allowed: bool,
fail: bool,
}
#[async_trait]
impl PermissionChecker for MockPermissionChecker {
async fn has_permission(
&self,
_login_id: &str,
_permission: &str,
) -> GarrisonResult<bool> {
Ok(self.allowed)
}
async fn has_role(&self, _login_id: &str, _role: &str) -> GarrisonResult<bool> {
Ok(self.allowed)
}
async fn authorize(&self, _request: &AuthRequest) -> GarrisonResult<Decision> {
if self.fail {
return Err(GarrisonError::Dao("stp-dao-connect::".to_string()));
}
Ok(Decision {
allowed: self.allowed,
reason: if self.allowed {
DecisionReason::ExplicitAllow
} else {
DecisionReason::NoMatchingPermission
},
errors: Vec::new(),
checked_permissions: Vec::new(),
matched_roles: Vec::new(),
trace_id: None,
})
}
async fn has_any_permission(&self, _login_id: &str, _perms: &[&str]) -> bool {
self.allowed
}
async fn has_all_permissions(&self, _login_id: &str, _perms: &[&str]) -> bool {
self.allowed
}
}
fn make_logic_with_checker(allowed: bool, fail: bool) -> GarrisonLogicDefault {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let session = Arc::new(GarrisonSession::new(dao, 3600, 86400));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = false;
config.token_style = "uuid".to_string();
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(MockFirewall {
has_permission: true,
has_role: true,
});
let pc: Arc<dyn PermissionChecker> = Arc::new(MockPermissionChecker { allowed, fail });
GarrisonLogicDefault::new(session, Arc::new(config), firewall)
.with_permission_checker(pc)
}
#[tokio::test]
async fn check_permission_with_checker_allowed_returns_ok() {
let logic = make_logic_with_checker(true, false);
let token = logic
.login("checker-user-001", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.check_permission("user:read").await }).await
})
.await;
assert!(
result.is_ok(),
"permission_checker allowed=true 应返回 Ok,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_permission_with_checker_denied_returns_not_permission() {
let logic = make_logic_with_checker(false, false);
let token = logic
.login("checker-user-002", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.check_permission("user:read").await }).await
})
.await;
assert!(
matches!(result, Err(GarrisonError::NotPermission(_))),
"permission_checker allowed=false 应返回 NotPermission,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_permission_with_checker_error_propagates() {
let logic = make_logic_with_checker(false, true);
let token = logic
.login("checker-user-003", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.check_permission("user:read").await }).await
})
.await;
assert!(
matches!(result, Err(GarrisonError::Dao(ref s)) if s.contains("stp-dao-connect")),
"permission_checker authorize 错误应透传,实际: {:?}",
result
);
}
#[tokio::test]
async fn has_permission_with_checker_allowed_returns_true() {
let logic = make_logic_with_checker(true, false);
let token = logic
.login("checker-user-004", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.has_permission("user:read").await }).await
})
.await;
assert!(result.is_ok(), "应返回 Ok,实际: {:?}", result);
assert!(
result.unwrap(),
"permission_checker allowed=true 时 has_permission 应返回 true"
);
}
#[tokio::test]
async fn has_permission_with_checker_denied_returns_false() {
let logic = make_logic_with_checker(false, false);
let token = logic
.login("checker-user-005", &crate::stp::LoginParams::default())
.await
.unwrap();
let result = with_current_token(token, async {
with_default_tenant(async { logic.has_permission("user:read").await }).await
})
.await;
assert!(result.is_ok(), "应返回 Ok,实际: {:?}", result);
assert!(
!result.unwrap(),
"permission_checker allowed=false 时 has_permission 应返回 false"
);
}
}
}