use crate::action::{ActionContext, GlobalTools, Request, User};
use crate::token::TokenManager;
use jsonwebtoken::Algorithm;
use serde_json::json;
use std::sync::Arc;
fn create_test_token_manager() -> TokenManager {
TokenManager::new_symmetric(
"test_secret_key",
Algorithm::HS256,
"test_issuer".to_string(),
"test_audience".to_string(),
3600,
86400,
)
}
fn create_test_tools() -> Arc<GlobalTools> {
Arc::new(GlobalTools::new(create_test_token_manager()))
}
#[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 = vec!["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 = vec!["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 = vec!["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 = vec!["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 = vec!["admin".to_string()];
user.permissions = vec!["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_global_tools_new() {
let token_manager = create_test_token_manager();
let tools = GlobalTools::new(token_manager);
assert!(tools
.token_manager()
.generate_access_token("test_user", json!({}))
.is_ok());
}
#[test]
fn test_global_tools_register_and_get_tool() {
let tools = create_test_tools();
let redis_client = Arc::new("redis://localhost".to_string());
tools.register_tool("redis", redis_client.clone());
let retrieved: Option<Arc<String>> = tools.get_tool("redis");
assert!(retrieved.is_some());
assert_eq!(*retrieved.unwrap(), "redis://localhost");
}
#[test]
fn test_global_tools_get_nonexistent_tool() {
let tools = create_test_tools();
let result: Option<Arc<String>> = tools.get_tool("nonexistent");
assert!(result.is_none());
}
#[test]
fn test_global_tools_get_tool_wrong_type() {
let tools = create_test_tools();
let redis_client = Arc::new("redis://localhost".to_string());
tools.register_tool("redis", redis_client);
let result: Option<Arc<i32>> = tools.get_tool("redis");
assert!(result.is_none());
}
#[test]
fn test_global_tools_token_manager() {
let tools = create_test_tools();
let token_manager = tools.token_manager();
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!(context.table_config.is_none());
}
#[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_param() {
let request = Request::new(json!({
"name": "alice",
"age": 30
}));
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let name: String = context.param("name").unwrap();
assert_eq!(name, "alice");
let age: i64 = context.param("age").unwrap();
assert_eq!(age, 30);
}
#[test]
fn test_action_context_param_missing() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let result: Result<String, _> = context.param("name");
assert!(result.is_err());
}
#[test]
fn test_action_context_param_optional() {
let request = Request::new(json!({
"name": "alice"
}));
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let name: Option<String> = context.param_optional("name");
assert_eq!(name, Some("alice".to_string()));
let email: Option<String> = context.param_optional("email");
assert_eq!(email, None);
}
#[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_eq!(context.user_roles(), Vec::<String>::new());
let mut user = User::new(1, "alice");
user.roles = vec!["admin".to_string(), "user".to_string()];
let context = ActionContext::new(request, tools).with_user(user);
assert_eq!(
context.user_roles(),
vec!["admin".to_string(), "user".to_string()]
);
}
#[test]
fn test_action_context_user_roles_slice() {
let request = Request::new(json!({}));
let tools = create_test_tools();
let context = ActionContext::new(request.clone(), tools.clone());
assert_eq!(context.user_roles_slice(), &[] as &[String]);
let mut user = User::new(1, "alice");
user.roles = vec!["admin".to_string(), "user".to_string()];
let context = ActionContext::new(request, tools).with_user(user);
assert_eq!(
context.user_roles_slice(),
&["admin".to_string(), "user".to_string()]
);
}
#[test]
fn test_action_context_path_param() {
let request = Request::new(json!({})).path_param("id", "123");
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let id: String = context.path_param("id").unwrap();
assert_eq!(id, "123");
let result: Result<String, _> = context.path_param("nonexistent");
assert!(result.is_err());
}
#[test]
fn test_action_context_query_param() {
let request = Request::new(json!({})).query("page", "2");
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let page: u32 = context.query_param("page").unwrap();
assert_eq!(page, 2);
let result: Result<u32, _> = context.query_param("nonexistent");
assert!(result.is_err());
let result: Result<u32, _> = context.query_param("page");
assert!(result.is_ok()); }
#[test]
fn test_action_context_param_or() {
let request = Request::new(json!({ "page": 2 }));
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let page: i64 = context.param_or("page", 1);
assert_eq!(page, 2);
let limit: i64 = context.param_or("limit", 10);
assert_eq!(limit, 10);
}
#[test]
fn test_action_context_param_optional_strict() {
let request = Request::new(json!({
"age": 25,
"name": "alice",
"bad_age": "not_a_number"
}));
let tools = create_test_tools();
let context = ActionContext::new(request, tools);
let age: Result<Option<i64>, _> = context.param_optional_strict("age");
assert_eq!(age.unwrap(), Some(25));
let missing: Result<Option<i64>, _> = context.param_optional_strict("missing");
assert_eq!(missing.unwrap(), None);
let bad: Result<Option<i64>, _> = context.param_optional_strict("bad_age");
assert!(bad.is_err());
}
#[test]
fn test_global_tools_singleton() {
let initial_state = GlobalTools::get();
if let Err(err) = initial_state {
assert!(
matches!(err, crate::error::BaseError::ConfigError(_)),
"未初始化时应返回 ConfigError,实际返回: {:?}",
err
);
if let crate::error::BaseError::ConfigError(msg) = err {
assert!(
msg.contains("GlobalTools 未初始化"),
"错误信息应包含 '未初始化',实际: {}",
msg
);
}
let token_manager = create_test_token_manager();
let result = GlobalTools::init(token_manager);
assert!(result.is_ok(), "第一次初始化应成功,实际错误: {:?}", result.err());
let tools = GlobalTools::get();
assert!(tools.is_ok(), "初始化后获取应成功,实际错误: {:?}", tools.err());
let token_manager2 = create_test_token_manager();
let result2 = GlobalTools::init(token_manager2);
assert!(result2.is_err(), "重复初始化应返回错误");
let err2 = result2.unwrap_err();
assert!(
matches!(err2, crate::error::BaseError::ConfigError(_)),
"重复初始化应返回 ConfigError,实际: {:?}",
err2
);
if let crate::error::BaseError::ConfigError(msg) = err2 {
assert!(
msg.contains("GlobalTools 已初始化"),
"错误信息应包含 '已初始化',实际: {}",
msg
);
}
} else {
let token_manager = create_test_token_manager();
let result = GlobalTools::init(token_manager);
assert!(result.is_err(), "已初始化后重复初始化应返回错误");
let err = result.unwrap_err();
assert!(
matches!(err, crate::error::BaseError::ConfigError(_)),
"重复初始化应返回 ConfigError,实际: {:?}",
err
);
if let crate::error::BaseError::ConfigError(msg) = err {
assert!(
msg.contains("GlobalTools 已初始化"),
"错误信息应包含 '已初始化',实际: {}",
msg
);
}
let tools = GlobalTools::get();
assert!(tools.is_ok(), "已初始化后获取应成功,实际错误: {:?}", tools.err());
}
}
#[test]
fn test_action_context_new_with_global_tools() {
if GlobalTools::get().is_err() {
let token_manager = create_test_token_manager();
let _ = GlobalTools::init(token_manager);
}
let request = Request::new(serde_json::json!({ "name": "test" }));
let result = ActionContext::new_with_global_tools(request);
assert!(result.is_ok(), "全局单例已初始化时应成功创建上下文,实际错误: {:?}", result.err());
let context = result.unwrap();
assert!(context.user.is_none());
assert!(context.table_config.is_none());
}