use crate::error::BaseError;
use crate::table::{FieldConfig, FieldPermissions, FieldType, SortOrder, TableConfig, TableQuery};
use serde_json::json;
use std::collections::HashSet;
use std::sync::Arc;
fn create_test_table_config() -> Arc<TableConfig> {
Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"name",
FieldType::String { max_length: 50 },
))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"email",
FieldType::String { max_length: 100 },
))
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("salary", FieldType::Double).permissions(FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
writable_roles: HashSet::from(["admin".to_string()]),
filterable_roles: HashSet::from(["admin".to_string()]),
sortable_roles: HashSet::from(["admin".to_string()]),
}),
)
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("secret", FieldType::String { max_length: 255 }).permissions(
FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
writable_roles: HashSet::from(["admin".to_string()]),
filterable_roles: HashSet::from(["admin".to_string()]),
sortable_roles: HashSet::from(["admin".to_string()]),
},
),
)
.expect("有效字段配置应注册成功"),
)
}
#[test]
fn test_table_query_new() {
let table_config = create_test_table_config();
let query = TableQuery::new(
table_config.clone(),
Arc::from(vec!["user".to_string()]),
None,
);
assert_eq!(query.get_table_config().table_name, "users");
assert_eq!(query.get_user_roles(), &["user"]);
assert!(query.get_query_params().fields.is_none());
assert!(query.get_query_params().where_conditions.is_empty());
assert!(query.get_query_params().order_by.is_empty());
}
#[test]
fn test_select_fields_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.select_fields(&["id", "name", "email"]);
assert!(result.is_ok());
let query = result.unwrap();
let fields = query.get_query_params().fields.as_ref().unwrap();
assert_eq!(fields.len(), 3);
assert!(fields.contains(&"id".to_string()));
assert!(fields.contains(&"name".to_string()));
assert!(fields.contains(&"email".to_string()));
}
#[test]
fn test_select_fields_rejects_empty_list() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let err = query
.select_fields(&[])
.expect_err("空字段选择列表不应被接受");
assert!(matches!(
err,
BaseError::ParamInvalid(field, _) if field == "fields"
));
}
#[test]
fn test_select_fields_not_found() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.select_fields(&["id", "nonexistent"]);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldNotFound(table, field) => {
assert_eq!(table, "users");
assert_eq!(field, "nonexistent");
}
_ => panic!("期望 FieldNotFound 错误"),
}
}
#[test]
fn test_select_fields_permission_denied() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.select_fields(&["id", "salary"]);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(table, field, msg) => {
assert_eq!(table, "users");
assert_eq!(field, "salary");
assert_eq!(msg, "用户无读取权限");
}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_select_fields_admin_can_read_all() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let result = query.select_fields(&["id", "name", "salary", "secret"]);
assert!(result.is_ok());
let query = result.unwrap();
let fields = query.get_query_params().fields.as_ref().unwrap();
assert_eq!(fields.len(), 4);
}
#[test]
fn test_where_eq_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_eq("name", json!("alice"));
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().where_conditions.len(), 1);
}
#[test]
fn test_where_eq_field_not_found() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_eq("nonexistent", json!("value"));
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldNotFound(table, field) => {
assert_eq!(table, "users");
assert_eq!(field, "nonexistent");
}
_ => panic!("期望 FieldNotFound 错误"),
}
}
#[test]
fn test_where_eq_permission_denied() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_eq("salary", json!(50000));
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(table, field, msg) => {
assert_eq!(table, "users");
assert_eq!(field, "salary");
assert_eq!(msg, "用户无筛选权限");
}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_where_in_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_in("name", vec![json!("alice"), json!("bob"), json!("charlie")]);
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().where_conditions.len(), 1);
}
#[test]
fn test_where_in_rejects_empty_values() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let err = query
.where_in("name", vec![])
.expect_err("空 IN 列表不应生成非法 SQL");
assert!(matches!(
err,
BaseError::ParamInvalid(field, _) if field == "values"
));
}
#[test]
fn test_where_not_in_rejects_empty_values() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let err = query
.where_not_in("name", vec![])
.expect_err("空 NOT IN 列表不应生成非法 SQL");
assert!(matches!(
err,
BaseError::ParamInvalid(field, _) if field == "values"
));
}
#[test]
fn test_where_in_permission_denied() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_in("salary", vec![json!(50000), json!(60000)]);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(_, _, _) => {}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_where_like_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_like("name", "%alice%".to_string());
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().where_conditions.len(), 1);
}
#[test]
fn test_where_contains_rejects_blank_keyword() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let err = query
.where_contains("name", " ")
.expect_err("空白关键词不应被转换成 %% 全匹配 LIKE");
assert!(matches!(
err,
BaseError::ParamInvalid(field, _) if field == "keyword"
));
}
#[test]
fn test_where_like_permission_denied() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_like("secret", "%test%".to_string());
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(_, _, _) => {}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_order_by_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.order_by("name", SortOrder::Asc);
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().order_by.len(), 1);
assert_eq!(query.get_query_params().order_by[0].0, "name");
assert_eq!(query.get_query_params().order_by[0].1, SortOrder::Asc);
}
#[test]
fn test_order_by_field_not_found() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.order_by("nonexistent", SortOrder::Asc);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldNotFound(table, field) => {
assert_eq!(table, "users");
assert_eq!(field, "nonexistent");
}
_ => panic!("期望 FieldNotFound 错误"),
}
}
#[test]
fn test_order_by_permission_denied() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.order_by("salary", SortOrder::Desc);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(table, field, msg) => {
assert_eq!(table, "users");
assert_eq!(field, "salary");
assert_eq!(msg, "用户无排序权限");
}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_order_by_no_sort_permission() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.order_by("secret", SortOrder::Asc);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(_, _, _) => {}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_page_success() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query.page(1, 20);
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().page, Some(1));
assert_eq!(query.get_query_params().page_size, Some(20));
}
#[test]
fn test_chained_calls() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query
.select_fields(&["id", "name", "email"])
.and_then(|q| q.where_eq("name", json!("alice")))
.and_then(|q| q.where_in("id", vec![json!(1), json!(2), json!(3)]))
.and_then(|q| q.order_by("name", SortOrder::Asc))
.and_then(|q| q.page(1, 20));
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().fields.as_ref().unwrap().len(), 3);
assert_eq!(query.get_query_params().where_conditions.len(), 2);
assert_eq!(query.get_query_params().order_by.len(), 1);
assert_eq!(query.get_query_params().page, Some(1));
assert_eq!(query.get_query_params().page_size, Some(20));
}
#[test]
fn test_multiple_where_conditions() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query
.where_eq("name", json!("alice"))
.and_then(|q| q.where_like("email", "%@example.com".to_string()))
.and_then(|q| q.where_in("id", vec![json!(1), json!(2)]));
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().where_conditions.len(), 3);
}
#[test]
fn test_multiple_order_by() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let result = query
.order_by("name", SortOrder::Asc)
.and_then(|q| q.order_by("id", SortOrder::Desc));
assert!(result.is_ok());
let query = result.unwrap();
assert_eq!(query.get_query_params().order_by.len(), 2);
assert_eq!(query.get_query_params().order_by[0].0, "name");
assert_eq!(query.get_query_params().order_by[0].1, SortOrder::Asc);
assert_eq!(query.get_query_params().order_by[1].0, "id");
assert_eq!(query.get_query_params().order_by[1].1, SortOrder::Desc);
}
#[test]
fn test_admin_can_use_all_fields() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let result = query
.select_fields(&["id", "name", "salary", "secret"])
.and_then(|q| q.where_eq("salary", json!(50000)))
.and_then(|q| q.order_by("salary", SortOrder::Desc));
assert!(result.is_ok());
}
#[test]
fn test_empty_user_roles() {
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec![]), None);
let result = query.select_fields(&["id", "name"]);
assert!(result.is_ok());
let table_config = create_test_table_config();
let query = TableQuery::new(table_config, Arc::from(vec![]), None);
let result = query.select_fields(&["salary"]);
assert!(result.is_err());
}
fn create_test_table_config_for_insert() -> Arc<TableConfig> {
Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("name", FieldType::String { max_length: 50 }).required(true))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("email", FieldType::String { max_length: 100 }).required(true))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("age", FieldType::Integer))
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("salary", FieldType::Double).permissions(FieldPermissions {
readable_roles: HashSet::from(["admin".to_string()]),
writable_roles: HashSet::from(["admin".to_string()]),
filterable_roles: HashSet::from(["admin".to_string()]),
sortable_roles: HashSet::from(["admin".to_string()]),
}),
)
.expect("有效字段配置应注册成功"),
)
}
#[test]
fn test_update_validate_field_not_found() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("nonexistent".to_string(), json!("value"));
let result = query.build_update_sql(&data);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldNotFound(table, field) => {
assert_eq!(table, "users");
assert_eq!(field, "nonexistent");
}
_ => panic!("期望 FieldNotFound 错误"),
}
}
#[test]
fn test_update_validate_permission_denied() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("salary".to_string(), json!(50000.0));
let result = query.validate_update_data(&data);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::FieldPermissionDenied(table, field, msg) => {
assert_eq!(table, "users");
assert_eq!(field, "salary");
assert_eq!(msg, "用户无写入权限");
}
_ => panic!("期望 FieldPermissionDenied 错误"),
}
}
#[test]
fn test_update_validate_success() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("email".to_string(), json!("zhangsan@example.com"));
data.insert("age".to_string(), json!(25));
let result = query.validate_update_data(&data);
assert!(result.is_ok());
}
#[test]
fn test_update_validate_admin_can_write_all() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("salary".to_string(), json!(50000.0));
let result = query.validate_update_data(&data);
assert!(result.is_ok());
}
#[test]
fn test_update_validate_type_validation() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("age".to_string(), json!("not a number"));
let result = query.validate_update_data(&data);
assert!(result.is_err());
match result.unwrap_err() {
BaseError::InvalidFieldType(_, _) => {}
_ => panic!("期望 InvalidFieldType 错误"),
}
}
#[test]
fn test_build_update_sql_basic() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("email".to_string(), json!("zhangsan@example.com"));
let query = TableQuery::new(
table_config.clone(),
Arc::from(vec!["user".to_string()]),
None,
);
let result = query.build_update_sql(&data);
assert!(matches!(result, Err(BaseError::MissingWhereClause(op)) if op == "UPDATE"));
let query =
TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None).allow_full_table();
let (sql, params) = query.build_update_sql(&data).unwrap();
assert!(sql.contains("UPDATE `users`"));
assert!(sql.contains("SET"));
assert!(sql.contains("`name` = ?"));
assert!(sql.contains("`email` = ?"));
assert_eq!(params.len(), 2);
}
#[test]
fn test_build_update_sql_with_where() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
let query = query.where_eq("id", json!(1)).unwrap();
let result = query.build_update_sql(&data);
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("UPDATE `users`"));
assert!(sql.contains("SET `name` = ?"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` = ?"));
assert_eq!(params.len(), 2);
}
#[test]
fn test_build_update_sql_with_multiple_where() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
data.insert("age".to_string(), json!(25));
let query = query
.where_eq("id", json!(1))
.unwrap()
.where_like("email", "%@example.com".to_string())
.unwrap();
let result = query.build_update_sql(&data);
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("UPDATE `users`"));
assert!(sql.contains("SET"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` = ?"));
assert!(sql.contains("AND"));
assert!(sql.contains("`email` LIKE ?"));
assert_eq!(params.len(), 4);
}
#[test]
fn test_build_update_sql_with_in_condition() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
let query = query
.where_in("id", vec![json!(1), json!(2), json!(3)])
.unwrap();
let result = query.build_update_sql(&data);
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("UPDATE `users`"));
assert!(sql.contains("SET `name` = ?"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` IN (?, ?, ?)"));
assert_eq!(params.len(), 4);
}
#[test]
fn test_update_partial_fields() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
let result = query.validate_update_data(&data);
assert!(result.is_ok()); }
#[test]
fn test_update_empty_data() {
use std::collections::HashMap;
let table_config = create_test_table_config_for_insert();
let query = TableQuery::new(table_config, Arc::from(vec!["user".to_string()]), None);
let data = HashMap::new();
let result = query.build_update_sql(&data);
assert!(matches!(result, Err(BaseError::ParamInvalid(field, _)) if field == "data"));
}
fn create_test_table_config_with_soft_delete() -> Arc<TableConfig> {
Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"name",
FieldType::String { max_length: 50 },
))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"email",
FieldType::String { max_length: 100 },
))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("deleted_at", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.soft_delete_field("deleted_at"), )
}
fn create_test_table_config_without_soft_delete() -> Arc<TableConfig> {
Arc::new(
TableConfig::new("logs")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("message", FieldType::Text))
.expect("有效字段配置应注册成功"),
)
}
#[test]
fn test_build_delete_sql_basic() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(
table_config.clone(),
Arc::from(vec!["admin".to_string()]),
None,
);
let result = query.build_delete_sql();
assert!(matches!(result, Err(BaseError::MissingWhereClause(op)) if op == "DELETE"));
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None)
.allow_full_table();
let (sql, params) = query.build_delete_sql().unwrap();
assert_eq!(sql, "DELETE FROM `logs`");
assert_eq!(params.len(), 0);
}
#[test]
fn test_build_delete_sql_with_where_eq() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let query = query.where_eq("id", json!(1)).unwrap();
let result = query.build_delete_sql();
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("DELETE FROM `logs`"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` = ?"));
assert_eq!(params.len(), 1);
}
#[test]
fn test_build_delete_sql_with_multiple_where() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let query = query
.where_eq("id", json!(1))
.unwrap()
.where_like("message", "%error%".to_string())
.unwrap();
let result = query.build_delete_sql();
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("DELETE FROM `logs`"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` = ?"));
assert!(sql.contains("AND"));
assert!(sql.contains("`message` LIKE ?"));
assert_eq!(params.len(), 2);
}
#[test]
fn test_build_delete_sql_with_in_condition() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let query = query
.where_in("id", vec![json!(1), json!(2), json!(3)])
.unwrap();
let result = query.build_delete_sql();
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("DELETE FROM `logs`"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` IN (?, ?, ?)"));
assert_eq!(params.len(), 3);
}
#[test]
fn test_build_delete_sql_with_is_null() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let query = query.where_eq("id", json!(1)).unwrap();
let result = query.build_delete_sql();
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("DELETE FROM `logs`"));
assert!(sql.contains("WHERE"));
assert!(sql.contains("`id` = ?"));
assert_eq!(params.len(), 1);
}
#[test]
fn test_soft_delete_field_configured() {
let table_config = create_test_table_config_with_soft_delete();
assert_eq!(
table_config.soft_delete_field,
Some("deleted_at".to_string())
);
}
#[test]
fn test_hard_delete_field_not_configured() {
let table_config = create_test_table_config_without_soft_delete();
assert_eq!(table_config.soft_delete_field, None);
}
#[test]
fn test_delete_sql_all_where_conditions() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let query = query.where_eq("id", json!(1)).unwrap();
let result = query.build_delete_sql();
assert!(result.is_ok());
let (sql, params) = result.unwrap();
assert!(sql.contains("DELETE FROM `logs`"));
assert!(sql.contains("WHERE"));
assert_eq!(params.len(), 1);
}
#[test]
fn test_new_where_methods_build_sql() {
use crate::table::{FieldConfig, FieldType, TableConfig};
let config = std::sync::Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("age", FieldType::Integer))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"name",
FieldType::String { max_length: 50 },
))
.expect("有效字段配置应注册成功"),
);
let q = crate::table::TableQuery::new_without_pool(config)
.where_lt("age", serde_json::json!(18))
.unwrap()
.where_gte("id", serde_json::json!(1))
.unwrap()
.where_ne("name", serde_json::json!("admin"))
.unwrap()
.where_between("id", serde_json::json!(10), serde_json::json!(20))
.unwrap()
.where_null("name")
.unwrap()
.where_not_null("age")
.unwrap()
.where_not_in("id", vec![serde_json::json!(5), serde_json::json!(6)])
.unwrap();
let (sql, _) = q.build_select_sql_for_test().expect("build sql");
assert!(sql.contains("`age` < ?"), "Expected `age` < ? in: {}", sql);
assert!(sql.contains("`id` >= ?"), "Expected `id` >= ? in: {}", sql);
assert!(
sql.contains("`name` <> ?"),
"Expected `name` <> ? in: {}",
sql
);
assert!(
sql.contains("`id` BETWEEN ? AND ?"),
"Expected BETWEEN in: {}",
sql
);
assert!(
sql.contains("`name` IS NULL"),
"Expected IS NULL in: {}",
sql
);
assert!(
sql.contains("`age` IS NOT NULL"),
"Expected IS NOT NULL in: {}",
sql
);
assert!(
sql.contains("`id` NOT IN (?, ?)"),
"Expected NOT IN in: {}",
sql
);
}
fn create_test_table_config_with_defaults() -> Arc<TableConfig> {
Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("name", FieldType::String { max_length: 50 }).required(true))
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("status", FieldType::String { max_length: 20 })
.required(true)
.default_value(json!("active")),
)
.expect("有效字段配置应注册成功")
.field(FieldConfig::new("created_at", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.timestamps(true, false, false),
)
}
#[test]
fn test_insert_required_with_default_omitted_ok() {
use std::collections::HashMap;
let config = create_test_table_config_with_defaults();
let query = TableQuery::new_without_pool(config);
let mut data = HashMap::new();
data.insert("name".to_string(), json!("张三"));
let (sql, params) = query
.build_insert_sql_for_test(data)
.expect("required+default 字段省略时应自动补默认值并通过校验");
assert!(sql.contains("INSERT INTO `users`"));
assert!(sql.contains("`status`"), "status 默认值应入列: {}", sql);
assert!(
sql.contains("`created_at`"),
"created_at 应自动填充: {}",
sql
);
assert_eq!(params.len(), 3);
}
#[test]
fn test_insert_missing_required_no_default_errors() {
use std::collections::HashMap;
let config = create_test_table_config_with_defaults();
let query = TableQuery::new_without_pool(config);
let mut data = HashMap::new();
data.insert("status".to_string(), json!("active"));
let result = query.build_insert_sql_for_test(data);
assert!(
matches!(result, Err(BaseError::FieldRequired(ref f)) if f == "name"),
"省略无默认值的必填字段应报 FieldRequired,实际: {:?}",
result
);
}
#[test]
fn test_select_falls_back_to_default_order() {
let config = Arc::new(
TableConfig::new("users")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(FieldConfig::new(
"name",
FieldType::String { max_length: 50 },
))
.expect("有效字段配置应注册成功")
.default_order(vec![
("name".to_string(), SortOrder::Asc),
("id".to_string(), SortOrder::Desc),
]),
);
let query = TableQuery::new_without_pool(config);
let (sql, _) = query.build_select_sql_for_test().expect("build sql");
assert!(
sql.contains("ORDER BY `name` ASC, `id` DESC"),
"应回退到 default_order: {}",
sql
);
}
use crate::table::WhereCondition;
#[test]
fn test_where_or_renders_parenthesized_or() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let query = query
.select_fields(&["id", "name", "email"])
.expect("OR 语义测试只选择断言涉及的可读字段")
.where_eq("name", json!("alice"))
.unwrap()
.where_or(vec![
WhereCondition::Eq {
field: "email".into(),
value: json!("a@x.com"),
},
WhereCondition::Gt {
field: "id".into(),
value: json!(100),
},
])
.unwrap();
let (sql, params) = query.build_select_sql_for_test().expect("build sql");
assert!(
sql.contains("`name` = ? AND (`email` = ? OR `id` > ?)"),
"OR 组应括号包裹并以 AND 接在顶层条件后: {}",
sql
);
assert_eq!(params.len(), 3, "应有 3 个占位符参数");
}
#[test]
fn test_nested_or_and_groups() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let query = query
.select_fields(&["id", "name", "email"])
.expect("嵌套 OR/AND 测试只选择断言涉及的可读字段")
.where_or(vec![
WhereCondition::Eq {
field: "name".into(),
value: json!("a"),
},
WhereCondition::And {
conditions: vec![
WhereCondition::Eq {
field: "email".into(),
value: json!("b"),
},
WhereCondition::Gte {
field: "id".into(),
value: json!(5),
},
],
},
])
.unwrap();
let (sql, params) = query.build_select_sql_for_test().expect("build sql");
assert!(
sql.contains("(`name` = ? OR (`email` = ? AND `id` >= ?))"),
"嵌套组括号应正确: {}",
sql
);
assert_eq!(params.len(), 3);
}
#[test]
fn test_empty_groups_rejected() {
let config = create_test_table_config();
let r_or =
TableQuery::new(config.clone(), Arc::from(vec!["user".to_string()]), None).where_or(vec![]);
assert!(
matches!(r_or, Err(BaseError::ParamInvalid(_, _))),
"空 OR 组应被拒绝"
);
let r_and = TableQuery::new(config.clone(), Arc::from(vec!["user".to_string()]), None)
.where_and(vec![]);
assert!(
matches!(r_and, Err(BaseError::ParamInvalid(_, _))),
"空 AND 组应被拒绝"
);
let r_nested = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None)
.where_and(vec![WhereCondition::Or { conditions: vec![] }]);
assert!(
matches!(r_nested, Err(BaseError::ParamInvalid(_, _))),
"嵌套空组应被拒绝"
);
}
#[test]
fn test_where_tree_rejects_empty_in_values() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_tree(WhereCondition::In {
field: "id".into(),
values: vec![],
});
assert!(
matches!(result, Err(BaseError::ParamInvalid(field, _)) if field == "values"),
"where_tree 不应接受空 IN 列表"
);
}
#[test]
fn test_where_group_rejects_empty_not_in_values() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_or(vec![WhereCondition::NotIn {
field: "id".into(),
values: vec![],
}]);
assert!(
matches!(result, Err(BaseError::ParamInvalid(field, _)) if field == "values"),
"where_or 不应递归接受空 NOT IN 列表"
);
}
#[test]
fn test_non_filterable_field_rejected() {
let config = Arc::new(
TableConfig::new("accounts")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("password", FieldType::String { max_length: 255 })
.filterable(false),
)
.expect("有效字段配置应注册成功"),
);
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_eq("password", json!("secret"));
assert!(
matches!(result, Err(BaseError::FieldPermissionDenied(_, _, _))),
"filterable(false) 字段应拒绝筛选: {:?}",
result.err()
);
}
#[test]
fn test_non_sortable_field_rejected() {
let config = Arc::new(
TableConfig::new("accounts")
.field(FieldConfig::new("id", FieldType::BigInt))
.expect("有效字段配置应注册成功")
.field(
FieldConfig::new("description", FieldType::String { max_length: 255 })
.sortable(false),
)
.expect("有效字段配置应注册成功"),
);
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.order_by("description", SortOrder::Asc);
assert!(
matches!(result, Err(BaseError::FieldPermissionDenied(_, _, _))),
"sortable(false) 字段应拒绝排序: {:?}",
result.err()
);
}
#[test]
fn test_where_or_permission_denied_in_group() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_or(vec![
WhereCondition::Eq {
field: "name".into(),
value: json!("ok"),
},
WhereCondition::Gt {
field: "salary".into(),
value: json!(1000),
},
]);
assert!(
matches!(result, Err(BaseError::FieldPermissionDenied(_, _, _))),
"组内 salary 无筛选权限应整组失败"
);
}
#[test]
fn test_where_or_field_not_found_in_group() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.where_or(vec![WhereCondition::Eq {
field: "nonexistent".into(),
value: json!(1),
}]);
assert!(
matches!(result, Err(BaseError::FieldNotFound(_, _))),
"组内不存在字段应失败"
);
}
#[test]
fn test_where_or_admin_can_filter_restricted() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["admin".to_string()]), None);
let query = query
.where_or(vec![
WhereCondition::Gt {
field: "salary".into(),
value: json!(1000),
},
WhereCondition::Eq {
field: "name".into(),
value: json!("boss"),
},
])
.expect("admin 应可筛选 salary");
let (sql, params) = query.build_select_sql_for_test().expect("build sql");
assert!(sql.contains("(`salary` > ? OR `name` = ?)"), "{}", sql);
assert_eq!(params.len(), 2);
}
#[test]
fn test_where_tree_depth_limit() {
let config = create_test_table_config();
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let mut node = WhereCondition::Eq {
field: "id".into(),
value: json!(1),
};
for _ in 0..40 {
node = WhereCondition::And {
conditions: vec![node],
};
}
let result = query.where_tree(node);
assert!(
matches!(result, Err(BaseError::ParamInvalid(_, _))),
"超深嵌套应返回 ParamInvalid"
);
}
#[test]
fn test_filter_json_roundtrip_to_where_condition() {
use crate::table::{Filter, IntoSqlCondition, SqlCondition, SqlOp};
#[derive(serde::Deserialize)]
struct LeafW {
value: i64,
}
impl IntoSqlCondition for LeafW {
fn into_sql_condition(self) -> SqlCondition {
SqlCondition {
column: "id",
op: SqlOp::Eq,
params: vec![json!(self.value)],
}
}
}
let j = json!({
"or": [
{"value": 1},
{"and": [{"value": 2}]}
]
});
let filter: Filter<LeafW> = serde_json::from_value(j).expect("deserialize Filter");
let wc = filter.into_where_condition();
match wc {
WhereCondition::Or { conditions } => {
assert_eq!(conditions.len(), 2);
assert!(matches!(conditions[0], WhereCondition::Eq { .. }));
assert!(matches!(conditions[1], WhereCondition::And { .. }));
}
other => panic!("应降解为 Or 组,实际: {:?}", other),
}
}
#[cfg(feature = "mysql")]
#[tokio::test]
async fn test_slow_query_warn_fires() {
use std::io::Write;
use std::sync::{Arc, Mutex};
use std::time::Duration;
struct BufWriter {
buf: Arc<Mutex<Vec<u8>>>,
}
impl Write for BufWriter {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.buf.lock().unwrap().write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
self.buf.lock().unwrap().flush()
}
}
struct BufMakeWriter {
buf: Arc<Mutex<Vec<u8>>>,
}
impl<'a> tracing_subscriber::fmt::MakeWriter<'a> for BufMakeWriter {
type Writer = BufWriter;
fn make_writer(&'a self) -> Self::Writer {
BufWriter {
buf: self.buf.clone(),
}
}
}
let buf = Arc::new(Mutex::new(Vec::new()));
let make_writer = BufMakeWriter { buf: buf.clone() };
let subscriber = tracing_subscriber::fmt()
.with_writer(make_writer)
.with_ansi(false)
.finish();
let _guard = tracing::subscriber::set_default(subscriber);
let result = TableQuery::timed(
Some(Duration::from_secs(0)),
None,
"test_table_name",
"test_operation",
async { 42 },
)
.await;
assert_eq!(result, 42, "返回值应透传");
let output = String::from_utf8(buf.lock().unwrap().clone()).expect("输出不是合法 UTF-8");
assert!(
output.contains("慢查询"),
"warn 应包含中文消息 '慢查询',输出: {:?}",
output
);
assert!(
output.contains("test_table_name"),
"warn 应包含表名,输出: {:?}",
output
);
assert!(
output.contains("test_operation"),
"warn 应包含操作名,输出: {:?}",
output
);
}