#![cfg(feature = "token")]
use crate::action::{ActionContext, Request, RequestMeta, User};
#[cfg(feature = "mysql")]
use crate::action::{TenantContext, TenantId, TenantResolution};
use crate::error::BaseError;
use crate::token::TokenManager;
use crate::tools::{Tools, ToolsBuilder};
use jsonwebtoken::Algorithm;
use serde_json::json;
use std::collections::HashSet;
use std::sync::Arc;
#[cfg(feature = "mysql")]
fn tenant_table() -> crate::table::TableDefinition {
crate::table::Table::new("tenant_rows")
.fields([
crate::table::Field::id("id"),
crate::table::Field::bigint("org_id")
.required()
.tenant_key(),
crate::table::Field::string("name", 64),
])
.build()
.expect("租户表定义应有效")
}
fn create_test_token_manager() -> TokenManager {
TokenManager::new_symmetric(
"test_secret_keyxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"test_issuer".to_string(),
"test_audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功")
}
fn create_test_tools() -> Arc<Tools> {
Arc::new(
ToolsBuilder::new()
.token(create_test_token_manager())
.build()
.expect("测试 Tools 应构建成功"),
)
}
#[test]
fn test_user_new() {
let user = User::new(1, "alice");
assert_eq!(user.id, 1);
assert_eq!(user.username, "alice");
assert_eq!(user.nickname, "");
assert_eq!(user.email, "");
assert_eq!(user.roles.len(), 0);
assert_eq!(user.permissions.len(), 0);
}
#[test]
fn test_user_has_permission() {
let mut user = User::new(1, "alice");
user.permissions = HashSet::from(["user:read".to_string(), "user:write".to_string()]);
assert!(user.has_permission("user:read"));
assert!(user.has_permission("user:write"));
assert!(!user.has_permission("user:delete"));
assert!(!user.has_permission("admin:access"));
}
#[test]
fn test_user_has_permission_empty() {
let user = User::new(1, "alice");
assert!(!user.has_permission("user:read"));
assert!(!user.has_permission("any:permission"));
}
#[test]
fn test_user_has_role() {
let mut user = User::new(1, "alice");
user.roles = HashSet::from(["admin".to_string(), "user".to_string()]);
assert!(user.has_role("admin"));
assert!(user.has_role("user"));
assert!(!user.has_role("guest"));
assert!(!user.has_role("superadmin"));
}
#[test]
fn test_user_has_role_empty() {
let user = User::new(1, "alice");
assert!(!user.has_role("admin"));
assert!(!user.has_role("any:role"));
}
#[test]
fn test_user_has_any_role() {
let mut user = User::new(1, "alice");
user.roles = HashSet::from(["admin".to_string(), "user".to_string()]);
assert!(user.has_any_role(&["admin".to_string()]));
assert!(user.has_any_role(&["user".to_string()]));
assert!(user.has_any_role(&["admin".to_string(), "guest".to_string()]));
assert!(user.has_any_role(&["guest".to_string(), "user".to_string()]));
assert!(!user.has_any_role(&["guest".to_string()]));
assert!(!user.has_any_role(&["guest".to_string(), "superadmin".to_string()]));
}
#[test]
fn test_user_has_any_role_empty_user_roles() {
let user = User::new(1, "alice");
assert!(!user.has_any_role(&["admin".to_string()]));
assert!(!user.has_any_role(&["admin".to_string(), "user".to_string()]));
}
#[test]
fn test_user_has_any_role_empty_check_roles() {
let mut user = User::new(1, "alice");
user.roles = HashSet::from(["admin".to_string()]);
assert!(!user.has_any_role(&[]));
}
#[test]
fn test_user_clone() {
let mut user = User::new(1, "alice");
user.nickname = "Alice".to_string();
user.email = "alice@example.com".to_string();
user.roles = HashSet::from(["admin".to_string()]);
user.permissions = HashSet::from(["user:read".to_string()]);
let cloned = user.clone();
assert_eq!(cloned.id, user.id);
assert_eq!(cloned.username, user.username);
assert_eq!(cloned.nickname, user.nickname);
assert_eq!(cloned.email, user.email);
assert_eq!(cloned.roles, user.roles);
assert_eq!(cloned.permissions, user.permissions);
}
#[test]
fn test_tools_token_manager() {
let tools = create_test_tools();
let token_manager = tools.token().expect("TokenManager 应存在");
let token = token_manager.generate_access_token("user_123", json!({"role": "admin"}));
assert!(token.is_ok());
}
#[test]
fn test_action_context_new() {
let request = Request::new(json!({ "name": "alice" }));
let tools = create_test_tools();
let context = ActionContext::new(request.clone(), tools.clone());
assert!(context.user.is_none());
assert!(matches!(
context.table_definition(),
Err(BaseError::TableDefinitionNotSet)
));
}
#[cfg(feature = "mysql")]
#[test]
fn tenant_table_is_fail_closed_and_system_bypass_requires_capability() {
let base = ActionContext::new(Request::new(json!({})), create_test_tools())
.with_table_definition(tenant_table());
assert!(matches!(
base.table_query(),
Err(BaseError::Unauthorized(_))
));
let tenant = ActionContext::new(Request::new(json!({})), create_test_tools())
.with_table_definition(tenant_table())
.with_tenant(TenantContext::new(TenantId::new(7)));
let (tenant_sql, _) = tenant
.table_query()
.expect("租户上下文应生成查询")
.build_select_sql_for_test()
.expect("租户查询 SQL 应可构建");
assert!(tenant_sql.contains("`org_id` = ?"));
let system_user = User::new(1, "root").with_roles(["system"]);
let capability = match TenantResolution::system_for(&system_user)
.expect("已认证 system 角色应获得系统 capability")
{
TenantResolution::System(capability) => capability,
TenantResolution::Tenant(_) => panic!("system 角色不得被解析为普通租户"),
};
let system = ActionContext::new(Request::new(json!({})), create_test_tools())
.with_table_definition(tenant_table())
.with_system_tenant(capability);
assert!(matches!(
system.table_query(),
Err(BaseError::Unauthorized(_))
));
let (system_sql, _) = system
.system_table_query(capability)
.expect("显式传回当前请求 capability 后才可创建系统查询")
.build_select_sql_for_test()
.expect("system 查询 SQL 应可构建");
assert!(!system_sql.contains("`org_id` = ?"));
let other_user = User::new(2, "other-root").with_roles(["system"]);
let other_capability = match TenantResolution::system_for(&other_user)
.expect("另一个 system 角色应获得 capability")
{
TenantResolution::System(capability) => capability,
TenantResolution::Tenant(_) => panic!("system 角色不得被解析为普通租户"),
};
assert!(matches!(
system.system_table_query(other_capability),
Err(BaseError::PermissionDenied(_))
));
}
#[test]
fn test_action_context_with_user() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let user = User::new(1, "alice");
let context = ActionContext::new(request, tools).with_user(user.clone());
assert!(context.user.is_some());
assert_eq!(context.user.unwrap().id, 1);
}
#[test]
fn test_action_context_authenticated_user_getter() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let context = ActionContext::new(request.clone(), tools.clone());
assert!(context.authenticated_user().is_none());
let context = ActionContext::new(request, tools).with_user(User::new(1, "alice"));
let user = context
.authenticated_user()
.expect("内部注入用户后应可只读获取");
assert_eq!(user.id, 1);
assert_eq!(user.username, "alice");
}
#[test]
fn test_action_context_user_roles() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let context = ActionContext::new(request.clone(), tools.clone());
assert!(context.user_roles().is_empty());
let mut user = User::new(1, "alice");
user.roles = HashSet::from(["admin".to_string(), "user".to_string()]);
let context = ActionContext::new(request, tools).with_user(user);
let roles = context.user_roles();
assert!(roles.contains(&"admin".to_string()));
assert!(roles.contains(&"user".to_string()));
assert_eq!(roles.len(), 2);
}
#[test]
fn test_action_context_user_roles_set() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let context = ActionContext::new(request.clone(), tools.clone());
assert!(context.user_roles_set().is_none());
let mut user = User::new(1, "alice");
user.roles = HashSet::from(["admin".to_string(), "user".to_string()]);
let context = ActionContext::new(request, tools).with_user(user);
let roles_set = context.user_roles_set().unwrap();
assert!(roles_set.contains("admin"));
assert!(roles_set.contains("user"));
assert!(!roles_set.contains("guest"));
}
#[test]
fn action_context_keeps_the_explicit_app_tools() {
let tools = create_test_tools();
let context = ActionContext::new(
Request::new(serde_json::json!({ "name": "test" })),
Arc::clone(&tools),
);
assert!(std::ptr::eq(context.tools(), tools.as_ref()));
assert!(context.user.is_none());
assert!(matches!(
context.table_definition(),
Err(BaseError::TableDefinitionNotSet)
));
}
#[test]
fn test_action_context_request_meta_default_and_builder_paths() {
let context = ActionContext::new(Request::new(json!({})), create_test_tools());
assert_eq!(context.request_meta, RequestMeta::default());
let meta = RequestMeta::new()
.with_method("PATCH")
.with_original_uri("/users/42")
.with_peer_addr("127.0.0.1:43120".parse().expect("peer 地址应合法"));
let context = context.with_request_meta(meta.clone());
assert_eq!(context.request_meta, meta);
}