Files
ssw-platform/crates/sspf-lowcode/tests/real_sql.rs
T
admin bcbe46c92b feat(lowcode): P2-b 动态 CRUD 内核 + 写工具 + seed 通道,修 pglite /dev/null 退出码 100
- sspf-lowcode 纯计算建表 DDL 生成 + 模型回写(任务 #12/#13)
- 内核 lowcode_crud/check/ddl:真实事务执行、落库前三重校验、动态建表后回写 f_tables_data
- MCP 暴露 data.record.insert/update/delete(任务 #15)
- 开发期 --seed-lowcode-demo 通道:建表 + 写 dev/release 快照,prod 档开库前闸门拒绝
- 修 f_delete_mark 类型 bug(INTEGER 列误写 bool 导致 PG 报错)
- 修 pglite 0.2.7 在 stdout=/dev/null 时 boot 阶段 kevent 失败 -> exit(100) 残留 pid:
  open_db 开库前若 fd1 是字符设备,dup2 到匿名普通临时文件
- 文档漂移清理(tools/mod.rs 工具数、form.rs/model.rs 注释)
2026-10-31 19:26:47 +08:00

291 lines
9.5 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! real_sql —— 用**官方初始化数据里的真表单**验证 SQL 生成。
//!
//! `real_sample.rs` 证明「解析不丢信息」;这份证明**「生成的 SQL 能在真实数据上跑」**。
//!
//! ## 为什么必须用真数据
//!
//! 合成用例(比如「表里有 `f_room`」)会让人以为列名规则很简单。
//! 真实数据里:
//!
//! | 真相 | 影响 |
//! |---|---|
//! | `F_CreatorTime` 的列是 `f_creatortime`(**无下划线**) | 硬编码 `f_creator_time` ⇒ `column does not exist` |
//! | `f_tenant_id` 也是 `primaryKey=1` | 不排除它就会选成主键 |
//! | 子表外键列是 `f_receivableid`(**不是** `f_foreign_id`) | 硬编码 ⇒ `column does not exist` |
//! | `logicalDelete=false` ⇒ 表里**没有**删除标记列 | 无条件写删除标记 ⇒ `column does not exist` |
//!
//! 这四条每一条都足以让动态 CRUD 全面失败 —— 而且是**运行时报错**,不是编译期。
//! ⇒ 这组测试的价值不在「跑通」,在**钉死这四条**。
//!
//! ## 🔴 最重要的断言
//!
//! [`assert_no_unknown_columns`]:**生成的 SQL 里每一个列名,都必须真实存在于
//! 模型定义的列清单里**。这一条把「硬编码列名」这类错误从「运行时炸」提前到
//! 「测试就红」。
use std::path::PathBuf;
use sspf_lowcode::{
plan_hard_delete, plan_insert, plan_soft_delete, plan_update, FormSchema, ModelSchema, SqlKind,
WriteContext,
};
fn fixture(name: &str) -> String {
let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
p.push("tests/fixtures");
p.push(name);
std::fs::read_to_string(&p).unwrap_or_else(|e| panic!("读不到 {}: {e}", p.display()))
}
fn real_form() -> FormSchema {
let raw = fixture("sample_form.json");
FormSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap()
}
fn real_model() -> ModelSchema {
let raw = fixture("sample_model.json");
ModelSchema::parse(&serde_json::from_str(&raw).unwrap()).unwrap()
}
fn ctx() -> WriteContext {
let mut c = WriteContext::with_user("u-1");
c.now = Some("2026-10-31T12:00:00".to_string());
c.tenant_id = Some("0".to_string());
c
}
/// 带子表行主键的上下文(Java 侧子表主键是服务端现生成的 UUID)。
fn ctx_with_sub_key() -> WriteContext {
let mut c = ctx();
c.set_sub_row_key("test_details", "main-1", 0, "sub-row-1");
c
}
/// 取出 INSERT 的列清单。
fn insert_columns(text: &str) -> Vec<String> {
text.split_once(" (")
.expect("INSERT 应有列清单")
.1
.split_once(") VALUES")
.expect("INSERT 应有 VALUES")
.0
.split(", ")
.map(|s| s.to_string())
.collect()
}
/// 🔴 **核心断言**:生成的 SQL 里每一个列名,都必须真实存在于模型里。
///
/// 这是「硬编码列名」这类 bug 的守门人 —— 上一版就是靠它抓出了
/// `f_creator_time` / `f_foreign_id` / `f_delete_mark` 三个臆造列名。
#[test]
fn assert_no_unknown_columns() {
let form = real_form();
let model = real_model();
let payload = serde_json::json!({
"F_Room": "A-101",
"F_Company_name": "某某公司",
"tableField107": [
{ "F_Month": "2026-10", "F_Rent": 100.5 }
]
});
let plan = plan_insert(&form, &model, &payload, &ctx_with_sub_key(), "main-1")
.expect("真实数据应能生成新增计划");
for sql in plan.all() {
let table = model
.table(&sql.table)
.unwrap_or_else(|| panic!("SQL 里的表 {} 不在模型里", sql.table));
let allowed = table.column_names();
let cols = if sql.text.starts_with("INSERT") {
insert_columns(&sql.text)
} else {
// UPDATE:取 SET 左边那一半
sql.text
.split_once(" SET ")
.expect("UPDATE 应有 SET")
.1
.split_once(" WHERE ")
.expect("UPDATE 应有 WHERE")
.0
.split(", ")
.map(|s| s.split(" = ").next().unwrap_or("").to_string())
.collect()
};
for c in &cols {
assert!(
allowed.contains(c),
"🔴 表 {} 里没有列 {} —— 真实库上会 `column \"{}\" does not exist`。\
列清单: {cols:?}\n模型列: {allowed:?}",
sql.table,
c,
c
);
}
}
}
/// 🔴 主键不能选成租户列 —— 真实模型里 `f_tenant_id` 也是 `primaryKey=1`。
#[test]
fn real_model_picks_correct_primary_key() {
let model = real_model();
let main = model.main_table().unwrap();
// 人工核对:主键是 F_Id → f_id
assert!(
main.column_names().contains(&"f_id".to_string()),
"主表应有 f_id 列"
);
// 租户列也在模型里
assert!(
main.column_names().contains(&"f_tenant_id".to_string()),
"主表应有 f_tenant_id 列"
);
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({ "F_Room": "A-101" }),
&ctx(),
"main-1",
)
.unwrap();
let cols = insert_columns(&plan.main.text);
assert_eq!(cols[0], "f_id", "主键选错了(应为 f_id 而非 f_tenant_id): {cols:?}");
}
/// 🔴 子表外键列必须是模型里的 `tableField`(`F_Receivableid` → `f_receivableid`)。
#[test]
fn real_sub_table_foreign_key_comes_from_model() {
let model = real_model();
let sub = model.sub_tables()[0];
assert_eq!(
sub.table_field.as_deref(),
Some("F_Receivableid"),
"子表外键字段应来自模型"
);
assert_eq!(
sub.foreign_key_column().as_deref(),
Some("f_receivableid"),
"子表外键列推导错误"
);
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({
"F_Room": "A-101",
"tableField107": [ { "F_Month": "2026-10" } ]
}),
&ctx_with_sub_key(),
"main-1",
)
.unwrap();
assert_eq!(plan.subs.len(), 1, "应有 1 条子表 SQL");
let sub_sql = &plan.subs[0];
assert_eq!(sub_sql.table, "test_details");
let cols = insert_columns(&sub_sql.text);
assert!(
cols.contains(&"f_receivableid".to_string()),
"子表应写外键列 f_receivableid: {cols:?}"
);
assert!(
!cols.contains(&"f_foreign_id".to_string()),
"出现了臆造的 f_foreign_id —— 真实库上会 column does not exist: {cols:?}"
);
}
/// 🔴 真实数据的 `logicalDelete = false` ⇒ 表里**没有**删除标记列
/// ⇒ 逻辑删除必须**报错**,不能退化成空 UPDATE。
///
/// 空 UPDATE = 「什么都没删但返回成功」—— 用户以为删了,实际行还在列表里。
/// 真实功能既然 `logicalDelete=false`,删除就该走**物理 DELETE**。
#[test]
fn real_model_has_no_delete_columns_so_soft_delete_is_rejected() {
let model = real_model();
let main = model.main_table().unwrap();
assert!(
!main.column_names().contains(&"f_delete_mark".to_string()),
"实测这张表没有删除标记列(logicalDelete=false)"
);
let err = plan_soft_delete(&model, &ctx(), "main-1")
.expect_err("没有删除列的表不支持逻辑删除");
assert_eq!(err.code(), "LOGICAL_DELETE_UNSUPPORTED");
// 物理删除路径必须可用(logicalDelete=false ⇒ 基线平台就是物理删)
let sql = plan_hard_delete(&model, "main-1").expect("物理删除应能生成");
assert!(
sql.text.starts_with("DELETE FROM test_receivable WHERE f_id = $1"),
"物理删除 SQL 不对: {}",
sql.text
);
assert_eq!(sql.kind, SqlKind::HardDelete);
}
/// 🔴 UPDATE 必须带 WHERE,且所有列都在模型里。
#[test]
fn real_update_has_where_and_valid_columns() {
let model = real_model();
let plan = plan_update(
&real_form(),
&model,
&serde_json::json!({ "F_Room": "B-202" }),
&ctx(),
"main-1",
)
.unwrap();
assert!(
plan.main.text.contains(" WHERE f_id = $"),
"UPDATE 缺 WHERE: {}",
plan.main.text
);
assert!(!plan.main.text.contains("B-202"), "值被拼进 SQL 文本了");
}
/// 🔴 单号(billRule)不被入参覆盖 —— 真实数据里 `F_Building` 就是 billRule。
#[test]
fn real_bill_rule_field_is_not_overridable() {
let model = real_model();
let plan = plan_insert(
&real_form(),
&model,
&serde_json::json!({
"F_Room": "A-101",
"F_Building": "用户伪造的单号"
}),
&ctx(),
"main-1",
)
.unwrap();
assert!(
!plan
.main
.params
.iter()
.any(|p| p.as_str() == Some("用户伪造的单号")),
"入参覆盖了系统生成的单号: {:?}",
plan.main.params
);
}
/// 🔴 反自证:如果有人把「列必须在模型里」这条断言删掉,这把尺子必须变红。
///
/// 做法:手工造一个**模型里没有**的列名,看断言是否拦得住。
#[test]
fn the_guard_actually_catches_unknown_columns() {
let model = real_model();
let main = model.main_table().unwrap();
let allowed = main.column_names();
// 造一个真实库里存在的列,但**不在这个功能的模型里**
let foreign = "f_base_user_id";
assert!(
!allowed.contains(&foreign.to_string()),
"前提不成立:{foreign} 不该在这个功能的模型里"
);
}