use crate::error::BaseError;
use crate::table::table_query::SqlParam;
use crate::table::{col, Field, Record, SortOrder, Table, TableConfig, TableQuery, Tables};
use serde_json::json;
use serde_json::Value;
use std::sync::Arc;
fn build_config(table: Table) -> Arc<TableConfig> {
table.build().expect("测试表定义应有效").shared_config()
}
fn create_test_table_config() -> Arc<TableConfig> {
build_config(
Table::new("users").fields([
Field::id("id"),
Field::string("name", 50),
Field::string("email", 100),
Field::double("salary")
.readable_by(["admin"])
.writable_by(["admin"])
.filterable_by(["admin"])
.sortable_by(["admin"]),
Field::string("secret", 255)
.readable_by(["admin"])
.writable_by(["admin"])
.filterable_by(["admin"])
.sortable_by(["admin"]),
]),
)
}
#[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 tables_where_from_treats_empty_filters_as_noop() {
let query = TableQuery::new(
create_test_table_config(),
Arc::from(vec!["user".to_string()]),
None,
);
assert!(
Tables::new(query).where_from(&[]).is_ok(),
"空筛选集合应保留原查询,而不是构造非法空 AND 组"
);
}
#[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> {
build_config(
Table::new("users").fields([
Field::id("id"),
Field::string("name", 50).required(),
Field::string("email", 100).required(),
Field::integer("age"),
Field::double("salary")
.readable_by(["admin"])
.writable_by(["admin"])
.filterable_by(["admin"])
.sortable_by(["admin"]),
]),
)
}
#[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, Arc::from(vec!["user".to_string()]), None);
let result = query.build_update_sql(&data);
assert!(matches!(result, Err(BaseError::MissingWhereClause(op)) if op == "UPDATE"));
}
#[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> {
build_config(Table::new("users").fields([
Field::id("id"),
Field::string("name", 50),
Field::string("email", 100),
Field::soft_delete("deleted_at"),
]))
}
fn create_test_table_config_without_soft_delete() -> Arc<TableConfig> {
build_config(Table::new("logs").fields([Field::id("id"), Field::text("message")]))
}
#[test]
fn test_build_delete_sql_basic() {
let table_config = create_test_table_config_without_soft_delete();
let query = TableQuery::new(table_config, Arc::from(vec!["admin".to_string()]), None);
let result = query.build_delete_sql();
assert!(matches!(result, Err(BaseError::MissingWhereClause(op)) if op == "DELETE"));
}
#[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() {
let config = build_config(Table::new("users").fields([
Field::id("id"),
Field::integer("age"),
Field::string("name", 50),
]));
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> {
build_config(Table::new("users").fields([
Field::id("id"),
Field::string("name", 50).required(),
Field::string("status", 20).required().default("active"),
Field::created_at("created_at"),
]))
}
#[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_required_with_default_rejects_explicit_null() {
use std::collections::HashMap;
let config = create_test_table_config_with_defaults();
let query = TableQuery::new_without_pool(config);
let data = HashMap::from([
("name".to_string(), json!("张三")),
("status".to_string(), serde_json::Value::Null),
]);
let result = query.build_insert_sql_for_test(data);
assert!(matches!(result, Err(BaseError::FieldRequired(ref field)) if field == "status"));
}
#[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 = build_config(
Table::new("users")
.fields([Field::id("id"), Field::string("name", 50)])
.default_order(col("name").asc())
.then_order(col("id").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_where_value_type_is_checked_for_every_operator_operand() {
let config = build_config(Table::new("typed_rows").fields([
Field::id("id"),
Field::bigint("owner_id"),
Field::datetime("occurred_at"),
Field::json("payload"),
]));
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_eq("owner_id", json!("42"))
.is_err());
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_in("owner_id", vec![json!(1), json!("2")])
.is_err());
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_between("owner_id", json!(1), json!("2"))
.is_err());
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_like("owner_id", "%2%".to_string())
.is_err());
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_gt("payload", json!({"rank": 1}))
.is_err());
assert!(TableQuery::new_without_pool(Arc::clone(&config))
.where_eq("occurred_at", json!("2026-05-27T13:45:30+08:00"))
.is_ok());
assert!(TableQuery::new_without_pool(config)
.where_eq("occurred_at", json!("2026-05-27 13:45:30"))
.is_err());
}
#[test]
fn test_where_tree_validates_each_in_and_between_operand() {
let config =
build_config(Table::new("typed_rows").fields([Field::id("id"), Field::bigint("owner_id")]));
let in_error =
TableQuery::new_without_pool(Arc::clone(&config)).where_tree(WhereCondition::In {
field: "owner_id".into(),
values: vec![json!(1), json!("2")],
});
assert!(in_error.is_err());
let between_error = TableQuery::new_without_pool(config).where_tree(WhereCondition::Between {
field: "owner_id".into(),
lo: json!(1),
hi: json!("2"),
});
assert!(between_error.is_err());
}
#[test]
fn test_eq_and_ne_null_render_as_null_predicates_without_bind_params() {
let config = create_test_table_config();
let eq_query = TableQuery::new_without_pool(Arc::clone(&config))
.where_eq("email", serde_json::Value::Null)
.expect("Eq null 应被规范化为 IS NULL");
let (eq_sql, eq_params) = eq_query
.build_select_sql_for_test()
.expect("应构建 Eq null SQL");
assert!(eq_sql.contains("`email` IS NULL"));
assert!(eq_params.is_empty());
let ne_query = TableQuery::new_without_pool(config)
.where_ne("email", serde_json::Value::Null)
.expect("Ne null 应被规范化为 IS NOT NULL");
let (ne_sql, ne_params) = ne_query
.build_select_sql_for_test()
.expect("应构建 Ne null SQL");
assert!(ne_sql.contains("`email` IS NOT NULL"));
assert!(ne_params.is_empty());
}
#[tokio::test]
async fn test_count_fails_closed_before_database_lookup_without_readable_fields() {
let config = build_config(
Table::new("private_rows").fields([
Field::bigint("id")
.required()
.primary_key()
.readable_by(["admin"]),
Field::string("secret", 64).readable_by(["admin"]),
]),
);
let error = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None)
.count()
.await
.expect_err("COUNT 不得绕过表的可读权限");
assert!(matches!(
error,
BaseError::FieldPermissionDenied(table, field, _)
if table == "private_rows" && field == "*"
));
}
#[test]
fn test_non_filterable_field_rejected() {
let config = build_config(Table::new("accounts").fields([
Field::id("id"),
Field::string("password", 255).not_filterable(),
]));
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 = build_config(Table::new("accounts").fields([
Field::id("id"),
Field::string("description", 255).not_sortable(),
]));
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_where_condition_json_roundtrip() {
let j = json!({
"type": "or",
"conditions": [
{"type": "eq", "field": "id", "value": 1},
{"type": "and", "conditions": [
{"type": "eq", "field": "id", "value": 2}
]}
]
});
let wc: WhereCondition = serde_json::from_value(j).expect("应反序列化 WhereCondition");
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),
}
}
#[test]
fn test_search_and_filter_bits_are_independent() {
let config = build_config(
Table::new("docs").fields([
Field::id("id"),
Field::string("both", 50).searchable().filterable(),
Field::string("search_only", 50)
.searchable()
.not_filterable(),
Field::string("filter_only", 50).filterable(),
Field::string("neither", 50).not_filterable(),
]),
);
let roles = || Arc::from(vec!["user".to_string()]);
let query = TableQuery::new(config.clone(), roles(), None)
.search(Some("alice"))
.expect("存在可搜索字段时搜索应成功");
let conditions = &query.get_query_params().where_conditions;
let [WhereCondition::Or { conditions: leaves }] = conditions.as_slice() else {
panic!("搜索应生成单个 OR 组,实际: {conditions:?}");
};
let mut searched = leaves
.iter()
.map(|leaf| leaf.field().expect("搜索叶子条件应有字段").to_string())
.collect::<Vec<_>>();
searched.sort();
assert_eq!(searched, ["both", "search_only"]);
let query = TableQuery::new(config.clone(), roles(), None);
assert!(query.where_eq("both", json!("x")).is_ok());
let query = TableQuery::new(config.clone(), roles(), None);
assert!(query.where_eq("filter_only", json!("x")).is_ok());
let query = TableQuery::new(config.clone(), roles(), None);
assert!(
matches!(
query.where_eq("search_only", json!("x")),
Err(BaseError::FieldPermissionDenied(_, _, _))
),
"searchable 不得连带开放结构化筛选"
);
let query = TableQuery::new(config, roles(), None);
assert!(
matches!(
query.where_eq("neither", json!("x")),
Err(BaseError::FieldPermissionDenied(_, _, _))
),
"未声明 filterable 的字段不得筛选"
);
}
#[test]
fn test_search_rejected_without_searchable_fields() {
let config = build_config(Table::new("docs").fields([
Field::id("id"),
Field::string("filter_only", 50).filterable(),
]));
let query = TableQuery::new(config, Arc::from(vec!["user".to_string()]), None);
let result = query.search(Some("alice"));
assert!(
matches!(result, Err(BaseError::PermissionDenied(_))),
"filterable 不得连带开放关键词搜索: {:?}",
result.err()
);
}
#[test]
fn test_search_skips_unreadable_searchable_fields() {
let config = build_config(
Table::new("docs").fields([
Field::id("id"),
Field::string("admin_note", 50)
.searchable()
.readable_by(["admin"]),
]),
);
let user_query = TableQuery::new(config.clone(), Arc::from(vec!["user".to_string()]), None);
assert!(matches!(
user_query.search(Some("alice")),
Err(BaseError::PermissionDenied(_))
));
let admin_query = TableQuery::new(config, Arc::from(vec!["admin".to_string()]), None);
assert!(admin_query.search(Some("alice")).is_ok());
}
#[test]
fn test_where_primary_key_eq_bypasses_filter_permission() {
let config = build_config(
Table::new("accounts")
.fields([Field::id("id").not_filterable(), Field::string("name", 50)]),
);
let roles = || Arc::from(vec!["user".to_string()]);
let query = TableQuery::new(config.clone(), roles(), None);
assert!(matches!(
query.where_eq("id", json!(1)),
Err(BaseError::FieldPermissionDenied(_, _, _))
));
let query = TableQuery::new(config.clone(), roles(), None);
let query = query
.where_primary_key_eq(json!(1))
.expect("主键等值条件应绕过筛选权限");
assert_eq!(query.get_query_params().where_conditions.len(), 1);
let query = TableQuery::new(config, roles(), None);
assert!(matches!(
query.where_primary_key_eq(json!("not-a-number")),
Err(BaseError::InvalidFieldType(_, _))
));
}
#[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
);
}
fn test_config(table: crate::table::Table) -> Arc<TableConfig> {
table.build().expect("测试表定义应有效").shared_config()
}
fn test_query() -> TableQuery {
let config = test_config(
crate::table::Table::new("users")
.fields([crate::table::Field::integer("id").required().primary_key()]),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
TableQuery::new(config, roles, None)
}
#[test]
fn test_insert_omits_database_generated_auto_increment_field() {
let config = test_config(crate::table::Table::new("accounts").fields([
crate::table::Field::id("id"),
crate::table::Field::string("username", 64).required(),
]));
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None);
let data = std::collections::HashMap::from([(
"username".to_string(),
Value::String("alice".to_string()),
)]);
let prepared = query
.prepare_and_validate_insert(data)
.expect("数据库生成的自增主键不应要求调用方提供");
assert!(!prepared.contains_key("id"));
let data_with_null_id = std::collections::HashMap::from([
("id".to_string(), Value::Null),
("username".to_string(), Value::String("bob".to_string())),
]);
let prepared = query
.prepare_and_validate_insert(data_with_null_id)
.expect("null 自增主键应等价于未提供");
assert!(!prepared.contains_key("id"));
}
#[test]
fn tenant_scope_is_fail_closed_for_query_and_writes() {
let config = test_config(
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).required(),
]),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None)
.scope_tenant("org_id", serde_json::json!(7))
.expect("tenant scope 应有效");
let (sql, params) = query.build_select_sql(None).expect("租户查询 SQL 应可构建");
assert!(sql.contains("`org_id` = ?"));
assert!(params.contains(&SqlParam::Int(7)));
let prepared = query
.prepare_and_validate_insert(
[("name".to_string(), serde_json::json!("row"))]
.into_iter()
.collect(),
)
.expect("租户字段应由上下文注入");
assert_eq!(prepared.get("org_id"), Some(&serde_json::json!(7)));
let explicit_tenant = query.prepare_and_validate_insert(
[
("name".to_string(), serde_json::json!("row")),
("org_id".to_string(), serde_json::json!(9)),
]
.into_iter()
.collect(),
);
assert!(matches!(
explicit_tenant,
Err(BaseError::PermissionDenied(_))
));
}
#[test]
fn test_insert_rejects_explicit_null_for_non_writable_field() {
let config = test_config(crate::table::Table::new("accounts").fields([
crate::table::Field::id("id"),
crate::table::Field::string("username", 64).required(),
crate::table::Field::string("internal_note", 255).not_writable(),
]));
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None);
let data = std::collections::HashMap::from([
("username".to_string(), Value::String("alice".to_string())),
("internal_note".to_string(), Value::Null),
]);
let error = query
.prepare_and_validate_insert(data)
.expect_err("显式提交只读字段时,即使值为 null 也必须拒绝");
assert!(matches!(
error,
BaseError::FieldPermissionDenied(table, field, _)
if table == "accounts" && field == "internal_note"
));
}
#[test]
fn test_page_rejects_page_size_above_production_limit() {
let err = test_query()
.page(1, 101)
.expect_err("page_size 超过 100 应被拒绝");
assert!(matches!(err, BaseError::ParamInvalid(field, _) if field == "page_size"));
}
#[test]
fn trusted_prefetch_limit_reaches_sql_without_public_page_cap() {
let query = test_query()
.prefetch_limit(10_001)
.expect("可信树上限应允许 max_nodes + 1 探针");
let (sql, _) = query.build_select_sql(None).expect("有界预取 SQL 应可构建");
assert!(sql.ends_with("LIMIT 10001 OFFSET 0"), "实际 SQL: {sql}");
}
#[test]
fn test_default_order_rejects_unsortable_field() {
let config = test_config(
crate::table::Table::new("users")
.fields([
crate::table::Field::id("id"),
crate::table::Field::integer("secret_rank").not_sortable(),
])
.default_order(crate::table::col("secret_rank").desc()),
);
let roles: Arc<[String]> = Arc::from(Vec::<String>::new());
let query = TableQuery::new(config, roles, None);
let err = query
.build_select_sql(None)
.expect_err("默认排序不应绕过 sortable(false)");
assert!(
matches!(err, BaseError::FieldPermissionDenied(table, field, _) if table == "users" && field == "secret_rank")
);
}
#[test]
fn test_default_projection_excludes_unreadable_and_secret_fields() {
let config = test_config(
crate::table::Table::new("users").fields([
crate::table::Field::integer("id").required().primary_key(),
crate::table::Field::string("name", 64),
crate::table::Field::string("restricted", 64).readable_by(["admin"]),
crate::table::Field::string("password_hash", 255)
.secret()
.readable_by(["user"]),
]),
);
let roles: Arc<[String]> = Arc::from(vec!["user".to_string()]);
let query = TableQuery::new(config, roles, None);
query
.ensure_readable_projection()
.expect("存在可读且非 secret 字段时默认投影应可用");
let (sql, _) = query
.build_select_sql(None)
.expect("默认查询应只投影当前角色可读且非 secret 的字段");
assert_eq!(sql, "SELECT `id`, `name` FROM `users`");
assert!(!sql.contains("restricted"));
assert!(!sql.contains("password_hash"));
}
#[test]
fn test_select_projection_permission_matrix() {
let all_readable = test_config(crate::table::Table::new("public_rows").fields([
crate::table::Field::integer("id").required().primary_key(),
crate::table::Field::string("name", 64),
]));
let roles: Arc<[String]> = Arc::from(vec!["user".to_string()]);
let (sql, _) = TableQuery::new(all_readable, Arc::clone(&roles), None)
.build_select_sql(None)
.expect("全部字段可读时默认投影应成功");
assert_eq!(sql, "SELECT `id`, `name` FROM `public_rows`");
let partially_readable = test_config(
crate::table::Table::new("mixed_rows").fields([
crate::table::Field::integer("id").required().primary_key(),
crate::table::Field::string("restricted", 64).readable_by(["admin"]),
crate::table::Field::string("password_hash", 255)
.secret()
.readable_by(["user"]),
]),
);
let (partial_sql, _) =
TableQuery::new(Arc::clone(&partially_readable), Arc::clone(&roles), None)
.build_select_sql(None)
.expect("部分字段受限时默认投影应保留可读字段");
assert_eq!(partial_sql, "SELECT `id` FROM `mixed_rows`");
let explicit_err = TableQuery::new(partially_readable, Arc::clone(&roles), None)
.select_fields(&["id", "restricted"])
.expect_err("显式请求受限字段应被拒绝");
assert!(
matches!(explicit_err, BaseError::FieldPermissionDenied(table, field, _) if table == "mixed_rows" && field == "restricted")
);
let none_readable = test_config(
crate::table::Table::new("private_rows").fields([
crate::table::Field::integer("alpha")
.required()
.primary_key()
.readable_by(["admin"]),
crate::table::Field::integer("beta").readable_by(["admin"]),
]),
);
let none_err = TableQuery::new(none_readable, roles, None)
.build_select_sql(None)
.expect_err("零字段可读时默认投影应 fail-closed");
assert!(matches!(
none_err,
BaseError::FieldPermissionDenied(table, field, _) if table == "private_rows" && field == "*"
));
}
#[test]
fn test_ensure_readable_projection_fails_without_readable_fields() {
let config = test_config(
crate::table::Table::new("write_only_rows").fields([
crate::table::Field::integer("id")
.required()
.primary_key()
.readable_by(["admin"]),
crate::table::Field::string("payload", 255)
.secret()
.writable_by(["ingest"]),
]),
);
let roles: Arc<[String]> = Arc::from(vec!["ingest".to_string()]);
let query = TableQuery::new(config, roles, None);
let err = query
.ensure_readable_projection()
.expect_err("无可读字段时读投影门禁应 fail-closed");
assert!(matches!(
err,
BaseError::FieldPermissionDenied(table, field, _)
if table == "write_only_rows" && field == "*"
));
}
#[test]
fn test_default_projection_is_deterministic_and_excludes_hidden_fields() {
for _ in 0..64 {
let config = test_config(
crate::table::Table::new("secrets").fields([
crate::table::Field::id("id"),
crate::table::Field::integer("z_secret").readable_by(["admin"]),
crate::table::Field::integer("a_secret").readable_by(["admin"]),
crate::table::Field::integer("m_secret")
.secret()
.readable_by(["user"]),
]),
);
let roles: Arc<[String]> = Arc::from(vec!["user".to_string()]);
let query = TableQuery::new(config, roles, None);
let (sql, _) = query
.build_select_sql(None)
.expect("默认投影应保留公开字段");
assert_eq!(sql, "SELECT `id` FROM `secrets`");
}
}
#[test]
fn test_effective_pagination_applies_default_limit_to_data_query_sql() {
let (query, page, page_size) = test_query()
.with_effective_pagination()
.expect("默认分页参数应合法");
assert_eq!(page, 1);
assert_eq!(
page_size,
crate::table::query_params::DEFAULT_QUERY_PAGE_SIZE
);
let (sql, _) = query
.build_select_sql(None)
.expect("默认分页后的 SELECT SQL 应可构建");
assert!(
sql.contains(&format!(
" LIMIT {} OFFSET 0",
crate::table::query_params::DEFAULT_QUERY_PAGE_SIZE
)),
"分页数据查询必须包含默认 LIMIT,实际 SQL: {sql}"
);
}
fn upsert_batch_table() -> Table {
Table::new("feishu_option").fields([
Field::id("id"),
Field::string("option_id", 64).required(),
Field::string("source_key", 64).required(),
Field::string("label", 255).required(),
Field::integer("sort_order").required().default(0),
Field::json("extra"),
Field::created_at("created_at"),
Field::updated_at("updated_at"),
])
}
fn upsert_batch_query() -> TableQuery {
TableQuery::new_without_pool(build_config(upsert_batch_table()))
}
fn upsert_record(option_id: &str, label: &str) -> Record {
Record::new()
.set("option_id", option_id)
.set("source_key", "s1")
.set("label", label)
}
fn insert_sql_columns(sql: &str) -> Vec<String> {
let (_, rest) = sql.split_once('(').expect("INSERT 语句应含列清单");
let (columns, _) = rest.split_once(')').expect("INSERT 语句的列清单应闭合");
columns
.split(", ")
.map(|name| name.trim_matches('`').to_string())
.collect()
}
#[test]
fn created_at_is_filled_but_never_an_update_column() {
let query = upsert_batch_query();
let (prepared_rows, tail) = query
.upsert_batch_plan_for_test(
vec![upsert_record("o1", "甲"), upsert_record("o2", "乙")],
&["label"],
)
.expect("计划应成功")
.expect("非空批应有计划");
assert_eq!(prepared_rows.len(), 2);
for row in &prepared_rows {
assert!(
row.contains_key("created_at"),
"created_at 应补进 INSERT 列"
);
assert!(
row.contains_key("updated_at"),
"updated_at 应补进 INSERT 列"
);
assert!(!row.contains_key("id"), "自增列应由数据库生成");
}
assert_eq!(tail, vec!["label".to_string(), "updated_at".to_string()]);
}
#[test]
fn defaulted_columns_are_filled_but_stay_out_of_the_update_columns() {
let query = upsert_batch_query();
let (prepared_rows, tail) = query
.upsert_batch_plan_for_test(vec![upsert_record("o1", "甲")], &["label"])
.expect("计划应成功")
.expect("非空批应有计划");
assert_eq!(prepared_rows[0].get("sort_order"), Some(&json!(0)));
assert!(
!tail.contains(&"sort_order".to_string()),
"框架补出来的默认值不能进赋值列(否则就是「省略即重置」)"
);
let mut row = upsert_record("o1", "甲");
row.insert("sort_order", json!(5));
let (_, tail) = query
.upsert_batch_plan_for_test(vec![row], &["sort_order"])
.expect("计划应成功")
.expect("非空批应有计划");
assert!(tail.contains(&"sort_order".to_string()));
}
#[test]
fn updated_at_is_always_appended_to_the_update_columns() {
let (_, tail) = upsert_batch_query()
.upsert_batch_plan_for_test(vec![upsert_record("o1", "甲")], &["label"])
.expect("计划应成功")
.expect("非空批应有计划");
assert!(tail.contains(&"updated_at".to_string()));
let writable = Table::new("writable_updated_at").fields([
Field::id("id"),
Field::string("option_id", 64).required(),
Field::string("label", 255).required(),
Field::updated_at("updated_at").writable(),
]);
let query = TableQuery::new_without_pool(build_config(writable));
let mut row = Record::new().set("option_id", "o1").set("label", "甲");
row.insert("updated_at", json!(1_700_000_000));
let (_, tail) = query
.upsert_batch_plan_for_test(vec![row], &["label", "label", "updated_at"])
.expect("计划应成功")
.expect("非空批应有计划");
assert_eq!(
tail.iter().filter(|name| *name == "label").count(),
1,
"重复点名的赋值列应去重: {tail:?}"
);
assert_eq!(
tail.iter().filter(|name| *name == "updated_at").count(),
1,
"updated_at 不该被追加两次: {tail:?}"
);
}
#[test]
fn an_auto_increment_column_is_rejected_as_update_column() {
let query = upsert_batch_query();
let row = upsert_record("o1", "甲").set("id", Value::Null);
let err = query
.upsert_batch_plan_for_test(vec![row], &["id", "label"])
.expect_err("自增列不能当赋值列");
assert!(
matches!(
err,
BaseError::ParamInvalid(ref field, ref message)
if field == "update_columns" && message.contains("自增列")
),
"实际错误: {err:?}"
);
}
#[test]
fn rows_with_different_provided_columns_are_rejected() {
let query = upsert_batch_query();
let rows = vec![
upsert_record("o1", "甲").set("sort_order", 3),
upsert_record("o2", "乙"), ];
let err = query
.upsert_batch_plan_for_test(rows, &["label"])
.expect_err("各行提供的列集不一致应被拒绝");
assert!(
matches!(
err,
BaseError::ParamInvalid(ref field, ref message)
if field == "rows" && message.contains("第 2 条")
),
"实际错误: {err:?}"
);
}
#[test]
fn rows_with_different_prepared_column_sets_are_rejected() {
let query = upsert_batch_query();
let err = query
.upsert_batch_plan_for_test(
vec![
upsert_record("o1", "甲").set("extra", json!({"anomaly": "label 超长"})),
upsert_record("o2", "乙"),
],
&["label"],
)
.expect_err("列集异构应被拒绝");
assert!(matches!(err, BaseError::ParamInvalid(ref field, _) if field == "rows"));
let seq_table = Table::new("seq_rows").fields([
Field::bigint("seq")
.required()
.primary_key()
.auto_increment(),
Field::string("label", 64).required(),
]);
let query = TableQuery::new_without_pool(build_config(seq_table));
let err = query
.upsert_batch_plan_for_test(
vec![
Record::new().set("seq", 7).set("label", "甲"),
Record::new().set("seq", Value::Null).set("label", "乙"),
],
&["label"],
)
.expect_err("prepared 列集异构应被拒绝");
assert!(
matches!(
err,
BaseError::ParamInvalid(ref field, ref message)
if field == "rows" && message.contains("第 2 条")
),
"实际错误: {err:?}"
);
}
#[test]
fn an_empty_batch_plans_nothing() {
let plan = upsert_batch_query()
.upsert_batch_plan_for_test(Vec::new(), &["label"])
.expect("空批不是错误");
assert!(plan.is_none(), "空批不应产出任何计划");
}
#[test]
fn an_empty_update_columns_list_is_rejected() {
let err = upsert_batch_query()
.upsert_batch_plan_for_test(vec![upsert_record("o1", "甲")], &[])
.expect_err("空赋值列应被拒绝");
assert!(
matches!(err, BaseError::ParamInvalid(ref field, _) if field == "update_columns"),
"实际错误: {err:?}"
);
}
#[test]
fn where_conditions_are_rejected() {
let query = upsert_batch_query()
.where_eq("label", json!("甲"))
.expect("label 可筛选");
let err = query
.upsert_batch_plan_for_test(vec![upsert_record("o1", "甲")], &["label"])
.expect_err("带 where 的批量 upsert 应被拒绝");
assert!(
matches!(
err,
BaseError::ParamInvalid(ref field, ref message)
if field == "where" && message.contains("静默忽略")
),
"实际错误: {err:?}"
);
}
#[test]
fn a_soft_deleted_table_is_rejected() {
let config = build_config(Table::new("soft_rows").fields([
Field::id("id"),
Field::string("label", 64).required(),
Field::soft_delete("deleted_at"),
]));
let rows = vec![Record::new().set("label", "甲")];
let err = TableQuery::new_without_pool(Arc::clone(&config))
.upsert_batch_plan_for_test(rows.clone(), &["label"])
.expect_err("软删表未 with_trashed 时应被拒绝");
assert!(
matches!(err, BaseError::ParamInvalid(ref field, _) if field == "soft_delete_field"),
"实际错误: {err:?}"
);
let plan = TableQuery::new_without_pool(config)
.with_trashed()
.upsert_batch_plan_for_test(rows, &["label"])
.expect("with_trashed 后应放行");
assert!(plan.is_some());
}
#[test]
fn update_columns_must_come_from_the_provided_columns() {
let query = upsert_batch_query();
let row = upsert_record("o1", "甲");
for name in ["created_at", "updated_at", "sort_order"] {
let err = query
.upsert_batch_plan_for_test(vec![row.clone()], &["label", name])
.expect_err("框架补出来的列不能当赋值列");
assert!(
matches!(
err,
BaseError::ParamInvalid(ref field, ref message)
if field == "update_columns" && message.contains(name)
),
"赋值列 `{name}` 应被拒绝,实际错误: {err:?}"
);
}
}
#[test]
fn a_not_writable_field_is_rejected() {
let query = upsert_batch_query();
let row = upsert_record("o1", "甲").set("created_at", 1_700_000_000);
let err = query
.upsert_batch_plan_for_test(vec![row], &["label"])
.expect_err("显式提交只读列应被拒绝");
assert!(
matches!(
err,
BaseError::FieldPermissionDenied(ref table, ref field, _)
if table == "feishu_option" && field == "created_at"
),
"实际错误: {err:?}"
);
}
#[test]
fn prepared_rows_equal_the_single_row_insert_preparation() {
let config = build_config(Table::new("feishu_option").fields([
Field::id("id"),
Field::string("option_id", 64).required(),
Field::string("label", 255).required(),
Field::integer("sort_order").required().default(0),
]));
let query = TableQuery::new_without_pool(config);
let records = vec![
Record::new().set("option_id", "o1").set("label", "甲"),
Record::new().set("option_id", "o2").set("label", "乙"),
];
let (prepared_rows, tail) = query
.upsert_batch_plan_for_test(records.clone(), &["label"])
.expect("计划应成功")
.expect("非空批应有计划");
assert_eq!(tail, vec!["label".to_string()]);
for (index, record) in records.iter().enumerate() {
let single = query
.prepare_and_validate_insert(record.clone().into_columns())
.expect("单行插入准备应成功");
assert_eq!(prepared_rows[index], single, "批量路径不得有第二套 prepare");
let (sql, params) = query
.build_insert_sql_for_test(record.clone().into_columns())
.expect("单行插入 SQL 应可构建");
let mut columns = insert_sql_columns(&sql);
columns.sort();
let mut prepared_names: Vec<String> = single.keys().cloned().collect();
prepared_names.sort();
assert_eq!(columns, prepared_names, "INSERT 列集应与计划行一致: {sql}");
assert_eq!(params.len(), single.len(), "参数数 = 计划行列数");
let label: String = record.require("label").expect("label 应为字符串");
assert!(params.contains(&SqlParam::String(label)));
assert!(params.contains(&SqlParam::Int(0)), "默认值应作为参数绑定");
}
}