#![cfg(any(feature = "mysql", feature = "postgres"))]
use crate::action::builtin::{
AddAction, DelAction, GetAction, InsertResult, PutAction, SelectAction, TableAction,
};
use crate::action::{ActionContext, DynAction, Request, TypedAction, User};
use crate::error::BaseError;
use crate::table::{Field, Table, TableDefinition};
#[cfg(feature = "token")]
use crate::token::TokenManager;
use crate::tools::ToolsBuilder;
#[cfg(feature = "token")]
use jsonwebtoken::Algorithm;
use serde_json::json;
use std::sync::Arc;
fn test_definition() -> TableDefinition {
Table::new("test_users")
.label("测试用户")
.fields([Field::id("id"), Field::string("username", 50).required()])
.build()
.expect("测试表定义应有效")
}
fn make_ctx(body: serde_json::Value) -> ActionContext {
#[cfg(feature = "token")]
let tools = Arc::new(
ToolsBuilder::new()
.token(
TokenManager::new_symmetric(
"test_secret_keyxxxxxxxxxxxxxxxxx",
Algorithm::HS256,
"test_issuer".to_string(),
"test_audience".to_string(),
3600,
86400,
)
.expect("测试 TokenManager 应构建成功"),
)
.build()
.expect("测试 Tools 应构建成功"),
);
#[cfg(not(feature = "token"))]
let tools = Arc::new(ToolsBuilder::new().build().expect("测试 Tools 应构建成功"));
ActionContext::new(Request::new(body), tools)
}
#[test]
fn test_builtin_action_meta_without_entity_generics() {
let add = AddAction::new();
let put = PutAction::new();
let del = DelAction::new();
let get = GetAction::new();
let select = SelectAction::new();
let table = TableAction::new();
let cases: [(&dyn DynAction, &str, &str); 6] = [
(&add, "add", "新增数据"),
(&put, "put", "更新数据"),
(&del, "del", "删除数据"),
(&get, "get", "获取数据"),
(&select, "select", "查询列表"),
(&table, "table", "表元信息"),
];
for (action, name, display_name) in cases {
assert_eq!(action.meta().name, name);
assert_eq!(action.meta().display_name, display_name);
assert!(!action.meta().is_public);
}
}
#[test]
fn test_builtin_input_schema_non_empty() {
let action = SelectAction::new();
let schema = serde_json::to_value(action.input_schema()).expect("schema 应可序列化");
assert!(schema.is_object(), "input schema 应为 JSON 对象");
assert!(
schema.pointer("/properties/order_by").is_some(),
"SelectQuery schema 应暴露字符串排序字段"
);
}
#[test]
fn test_insert_result_id_preserves_json_contract() {
let result = InsertResult {
affected: 1,
id: json!(u64::MAX),
};
let value = serde_json::to_value(&result).expect("InsertResult 应可序列化");
assert_eq!(
value["id"],
json!(u64::MAX),
"InsertResult.id 必须保持整型无损编码"
);
assert_eq!(result.as_u64(), Some(u64::MAX));
let uuid_result = InsertResult {
affected: 1,
id: json!("550e8400-e29b-41d4-a716-446655440000"),
};
assert_eq!(
uuid_result.as_str(),
Some("550e8400-e29b-41d4-a716-446655440000"),
"UUID 主键应按字符串原样回填"
);
assert_eq!(uuid_result.as_u64(), None);
let schema = serde_json::to_value(schemars::schema_for!(InsertResult))
.expect("InsertResult schema 应可序列化");
assert!(
schema["properties"]["id"].is_object() || schema["properties"]["id"] == true,
"InsertResult.id 的 schema 应允许任意 JSON 值: {schema:?}"
);
}
#[tokio::test]
async fn test_table_action_dispatch_uses_bound_definition() {
let ctx = make_ctx(json!({})).with_table_definition(test_definition());
let action = TableAction::new();
let response = action.dispatch(ctx).await.expect("table dispatch 应成功");
let data = response.data.expect("table dispatch 应返回 data");
assert_eq!(data["table_name"], "test_users");
assert_eq!(data["primary_key"], "id");
assert_eq!(
data["input_schema"]["properties"]["username"]["maxLength"],
50
);
assert_eq!(
data["output_schema"]["properties"]["username"]["type"],
"string"
);
}
#[tokio::test]
async fn test_table_action_dispatch_scopes_schema_to_current_user_roles() {
let definition = Table::new("team_notes")
.fields([
Field::id("id"),
Field::string("title", 64).required(),
Field::string("admin_note", 255)
.readable_by(["admin"])
.writable_by(["admin"]),
Field::string("member_note", 255)
.readable_by(["member"])
.writable_by(["member"]),
])
.build()
.expect("角色字段表定义应有效");
let ctx = make_ctx(json!({}))
.with_user(User::new(7, "member").with_roles(["member"]))
.with_table_definition(definition);
let response = TableAction::new()
.dispatch(ctx)
.await
.expect("table dispatch 应成功");
let data = response.data.expect("table dispatch 应返回 data");
for schema_name in ["input_schema", "output_schema"] {
let properties = &data[schema_name]["properties"];
assert!(properties.get("title").is_some());
assert!(properties.get("member_note").is_some());
assert!(properties.get("admin_note").is_none());
}
}
#[tokio::test]
async fn test_add_dispatch_rejects_non_record_body() {
let result = AddAction::new().dispatch(make_ctx(json!([]))).await;
match result {
Err(BaseError::ParamInvalid(field, _)) => assert_eq!(field, "body"),
Err(other) => panic!("期望 ParamInvalid,实际: {other:?}"),
Ok(_) => panic!("数组请求体不应通过 Record 输入契约"),
}
}
#[tokio::test]
async fn test_put_dispatch_rejects_empty_record() {
let result = PutAction::new()
.dispatch(make_ctx(json!({"id": "user-1", "data": {}})))
.await;
match result {
Err(BaseError::ParamInvalid(field, _)) => assert_eq!(field, "data"),
Err(other) => panic!("期望 ParamInvalid,实际: {other:?}"),
Ok(_) => panic!("空更新对象不应通过 PutInput 契约"),
}
}
#[tokio::test]
async fn test_select_dispatch_accepts_dynamic_where_and_string_order() {
let result = SelectAction::new()
.dispatch(make_ctx(json!({
"page": 0,
"where": {"type": "eq", "field": "username", "value": "alice"},
"order_by": [{"field": "username"}]
})))
.await;
match result {
Err(BaseError::ParamInvalid(field, _)) => assert_eq!(field, "page/page_size"),
Err(other) => panic!("期望分页校验错误,实际: {other:?}"),
Ok(_) => panic!("page=0 不应通过分页校验"),
}
}
#[tokio::test]
async fn test_select_dispatch_checks_auth_before_count() {
let result = SelectAction::new()
.dispatch(make_ctx(json!({"count_total": true})))
.await;
match result {
Err(BaseError::Unauthorized(message)) => assert_eq!(message, "需要登录"),
Err(other) => panic!("期望鉴权错误,实际: {other:?}"),
Ok(_) => panic!("未登录请求不应进入 COUNT 路径"),
}
}