- 内核只有 lib:启动装配 → crates/sspf-admin(bin sspf-admin);37 个集成测试 → crates/tests(package sspf-tests)。
- demo/shop/books 的 spec/菜单/DDL/面 B 路由搬进 packs/{demo,shop,books};内核 modules/*.rs 只剩「面 A 适配器 + pub use」⇒ 内核零业务知识,示例可整目录搬走。面 A 与前端零改动。
- 示例表 DDL 按平台规则补 f_tenant_id + 复合主键(spec 不加 ⇒ JSON 键与响应逐字不变)。
- 修 is_builtin_table 只认 schema.sql 的漏洞:包表(含 asset_data_resource)此前可被建模页删除/改;现为「平台 DDL ∪ 包表」。
- sspf-compat-online_dev → onlinedev(包名/模块/文件/路由别名同步);6 个 5 行转发壳合并为 forward.rs。
- 新增 AR16 闸门 + lib.rs「30 秒地图」+ src/backend/README.md;pack-sync 补两处判据(module_key=None 的 urlAddress、apiFile 查存在性)。
- 回归:704 tests / 6 道静态闸门全绿;health 181 表;四个包面 A/面 B 运行时全部 200。
1134 lines
35 KiB
Rust
1134 lines
35 KiB
Rust
//! lowcode_crud 集成测试 —— **真实 pglite 库**上的动态 CRUD 闭环。
|
||
//!
|
||
//! ## 为什么必须是真库
|
||
//!
|
||
//! `sspf-lowcode` 的单测证明的是「SQL 文本长得对」。
|
||
//! 但真正的坑都在**执行**这一侧:
|
||
//!
|
||
//! | 坑 | 只有真库能暴露 |
|
||
//! |---|---|
|
||
//! | 参数没加 cast | `cannot convert between the Rust type String and the Postgres type timestamp` |
|
||
//! | 列名与真实表对不上 | `column "f_xxx" does not exist` |
|
||
//! | 占位符个数对不上 | `bind message supplies 3 parameters, but prepared statement requires 2` |
|
||
//! | 事务没回滚 | 主表失败后子表留孤儿行 |
|
||
//!
|
||
//! 这四条在 SQL 文本层面**全都看不出来**。
|
||
//!
|
||
//! ## 🔴 pglite 是进程级单例
|
||
//!
|
||
//! 第二个 `open_temp()` ⇒ `AlreadyOpen` ⇒ 全文件共用一个库(`OnceCell`),
|
||
//! 并用一把进程级 `Mutex` 把测试**整体串行**(Rust test harness 默认并发跑同文件的
|
||
//! `#[tokio::test]` ⇒ 共用库会互相踩数据)。
|
||
//!
|
||
//! ## 🔴 每个测试用**自己专属**的表名
|
||
//!
|
||
//! 不依赖测试执行顺序 —— 断言「不存在」之前自己造前置条件。
|
||
|
||
use serde_json::json;
|
||
use ssw_platform::lowcode_crud::{
|
||
build_context, delete_record, insert_record, now_iso, update_record, DEFAULT_TENANT_ID,
|
||
};
|
||
use sspf_core::db::Db;
|
||
use sspf_lowcode::{FormSchema, ModelSchema};
|
||
use tokio::sync::{Mutex, OnceCell};
|
||
|
||
/// 全文件共享的临时库。
|
||
static DB: OnceCell<Db> = OnceCell::const_new();
|
||
|
||
/// 把同文件的测试**整体**串行化(共用一个库 ⇒ 必须串行)。
|
||
static LOCK: Mutex<()> = Mutex::const_new(());
|
||
|
||
async fn db() -> &'static Db {
|
||
DB.get_or_init(|| async {
|
||
let db = Db::open_temp().await.expect("打开 pglite 临时库失败");
|
||
ssw_platform::bootstrap::ensure_schema_all(&db)
|
||
.await
|
||
.expect("ensure_schema_all 失败");
|
||
db
|
||
})
|
||
.await
|
||
}
|
||
|
||
// ============================================================
|
||
// 动态表:按 JNPF 建表规则造
|
||
// ============================================================
|
||
|
||
/// 建一张**主表**,列名形态照 JNPF 动态建表(`lower(vModel)`)。
|
||
///
|
||
/// 🔴 系统列的名字**从模型推导**,所以这里必须**逐字匹配**模型里推出来的名字:
|
||
/// - `F_Id` → `f_id`
|
||
/// - `F_CreatorTime` → `f_creatortime`(**无下划线**)
|
||
/// - `f_tenant_id` → `f_tenant_id`(平台常量,**有下划线**)
|
||
async fn create_main_table(db: &Db, table: &str) {
|
||
db.exec(&format!(
|
||
"CREATE TABLE {table} (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_room VARCHAR(100),
|
||
f_company_name VARCHAR(100),
|
||
f_amount NUMERIC(18,2),
|
||
f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE,
|
||
f_creatoruserid VARCHAR(50),
|
||
f_lastmodifytime TIMESTAMP(0) WITHOUT TIME ZONE,
|
||
f_lastmodifyuserid VARCHAR(50),
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
f_flow_task_id VARCHAR(50),
|
||
PRIMARY KEY (f_id)
|
||
)"
|
||
))
|
||
.await
|
||
.expect("建主表失败");
|
||
}
|
||
|
||
/// 建一张**子表**(外键列照模型的 `tableField` → `f_receivableid`)。
|
||
async fn create_sub_table(db: &Db, table: &str) {
|
||
db.exec(&format!(
|
||
"CREATE TABLE {table} (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_receivableid VARCHAR(50),
|
||
f_month VARCHAR(20),
|
||
f_rent NUMERIC(18,2),
|
||
f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE,
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
PRIMARY KEY (f_id)
|
||
)"
|
||
))
|
||
.await
|
||
.expect("建子表失败");
|
||
}
|
||
|
||
// ============================================================
|
||
// 表单 / 模型(合成,但列名形态照官方 fixture)
|
||
// ============================================================
|
||
|
||
/// 表单:主表字段 + 一个子表。
|
||
fn form_json(main: &str, sub: &str) -> String {
|
||
json!({
|
||
"formRef": "formRef",
|
||
"formModel": "formData",
|
||
"fields": [
|
||
{
|
||
"__vModel__": "F_Room",
|
||
"__config__": {
|
||
"jnpfKey": "input", "label": "房间", "layout": "colFormItem",
|
||
"tableName": main, "required": true
|
||
}
|
||
},
|
||
{
|
||
"__vModel__": "F_Company_name",
|
||
"__config__": {
|
||
"jnpfKey": "input", "label": "公司", "layout": "colFormItem",
|
||
"tableName": main
|
||
}
|
||
},
|
||
{
|
||
"__vModel__": "F_Amount",
|
||
"__config__": {
|
||
"jnpfKey": "inputNumber", "label": "金额", "layout": "colFormItem",
|
||
"tableName": main
|
||
}
|
||
},
|
||
{
|
||
"__vModel__": "tableField1",
|
||
"__config__": {
|
||
"jnpfKey": "table", "label": "明细", "layout": "rowFormItem",
|
||
"tableName": sub
|
||
},
|
||
"children": [
|
||
{
|
||
"__vModel__": "F_Month",
|
||
"__config__": {
|
||
"jnpfKey": "input", "label": "月份", "layout": "colFormItem",
|
||
"tableName": main, "relationTable": sub, "isSubTable": true,
|
||
"parentVModel": "tableField1"
|
||
}
|
||
},
|
||
{
|
||
"__vModel__": "F_Rent",
|
||
"__config__": {
|
||
"jnpfKey": "inputNumber", "label": "租金", "layout": "colFormItem",
|
||
"tableName": main, "relationTable": sub, "isSubTable": true,
|
||
"parentVModel": "tableField1"
|
||
}
|
||
}
|
||
]
|
||
}
|
||
]
|
||
})
|
||
.to_string()
|
||
}
|
||
|
||
/// 模型:主表 + 子表(`tableField` / `relationField` 照 JNPF 语义)。
|
||
fn model_json(main: &str, sub: &str) -> String {
|
||
json!([
|
||
{
|
||
"table": main,
|
||
"tableName": "主表",
|
||
"typeId": "1",
|
||
"fields": [
|
||
{ "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 },
|
||
{ "field": "F_Room", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Company_name", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Amount", "columnName": null, "dataType": "decimal" },
|
||
{ "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" },
|
||
{ "field": "F_CreatorUserId", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_LastModifyTime", "columnName": null, "dataType": "datetime" },
|
||
{ "field": "F_LastModifyUserId", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 },
|
||
{ "field": "f_flow_task_id", "columnName": null, "dataType": "varchar" }
|
||
]
|
||
},
|
||
{
|
||
"table": sub,
|
||
"tableName": "子表",
|
||
"typeId": "0",
|
||
"tableField": "F_Receivableid",
|
||
"relationField": "F_Id",
|
||
"fields": [
|
||
{ "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 },
|
||
{ "field": "F_Receivableid", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Month", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Rent", "columnName": null, "dataType": "decimal" },
|
||
{ "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" },
|
||
{ "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 }
|
||
]
|
||
}
|
||
])
|
||
.to_string()
|
||
}
|
||
|
||
fn parse_form(s: &str) -> FormSchema {
|
||
FormSchema::parse(&serde_json::from_str(s).expect("表单 JSON 非法")).expect("表单应可解析")
|
||
}
|
||
|
||
fn parse_model(s: &str) -> ModelSchema {
|
||
ModelSchema::parse(&serde_json::from_str(s).expect("模型 JSON 非法")).expect("模型应可解析")
|
||
}
|
||
|
||
/// 单租户上下文(租户值恒为 `"0"`)。
|
||
fn ctx() -> sspf_lowcode::WriteContext {
|
||
let now = now_iso();
|
||
let mut c = build_context(None, Some(DEFAULT_TENANT_ID), Some(&now));
|
||
c.user_id = Some("u-1".to_string());
|
||
c
|
||
}
|
||
|
||
// ============================================================
|
||
// ① 新增:主表 + 子表,值真的落库
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn insert_writes_main_and_sub_rows() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_a").await;
|
||
create_sub_table(db, "it_sub_a").await;
|
||
|
||
let form = parse_form(&form_json("it_main_a", "it_sub_a"));
|
||
let model = parse_model(&model_json("it_main_a", "it_sub_a"));
|
||
|
||
let payload = json!({
|
||
"F_Room": "A-101",
|
||
"F_Company_name": "某某公司",
|
||
"F_Amount": 1234.56,
|
||
"tableField1": [
|
||
{ "F_Month": "2026-10", "F_Rent": 100.5 },
|
||
{ "F_Month": "2026-11", "F_Rent": 200.25 }
|
||
]
|
||
});
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(db, &form, &model, &payload, &mut c, false)
|
||
.await
|
||
.expect("新增应成功");
|
||
assert!(!out.dry_run);
|
||
assert_eq!(out.statements, 3, "1 主表 + 2 子表 = 3 条: {out:?}");
|
||
|
||
// 主表行确实在库里
|
||
let rows = db
|
||
.query_json_params(
|
||
"SELECT f_id AS \"id\", f_room AS \"room\", f_amount AS \"amount\", \
|
||
f_tenant_id AS \"tenant\" FROM it_main_a WHERE f_id = $1",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查主表失败");
|
||
assert_eq!(rows.len(), 1, "主表行应落库");
|
||
assert_eq!(rows[0]["room"], json!("A-101"));
|
||
assert_eq!(rows[0]["amount"], json!(1234.56));
|
||
|
||
// 🔴 单租户口径:租户列必须**被写**成 "0"(Java `addTenantId()` 无条件执行)
|
||
assert_eq!(
|
||
rows[0]["tenant"],
|
||
json!(DEFAULT_TENANT_ID),
|
||
"🔴 单租户下 f_tenant_id 应写 \"0\"(不是 NULL)"
|
||
);
|
||
|
||
// 子表行确实在库里,且外键指向主表主键
|
||
let subs = db
|
||
.query_json_params(
|
||
"SELECT f_month AS \"month\", f_rent AS \"rent\", f_receivableid AS \"fk\" \
|
||
FROM it_sub_a WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(subs.len(), 2, "两条子表行都应落库: {subs:?}");
|
||
assert_eq!(subs[0]["month"], json!("2026-10"));
|
||
assert_eq!(subs[0]["rent"], json!(100.5));
|
||
assert_eq!(subs[0]["fk"], json!(out.id.as_str()), "子表外键应指向主表主键");
|
||
}
|
||
|
||
/// 🔴 数值列必须真的存成数值 —— 参数没 cast 就会报类型错。
|
||
#[tokio::test]
|
||
async fn numeric_columns_survive_real_roundtrip() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_num").await;
|
||
|
||
let form = parse_form(&form_json("it_main_num", "it_sub_num"));
|
||
let model = parse_model(&model_json("it_main_num", "it_sub_num"));
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "B-202", "F_Amount": 0.01 }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
let rows = db
|
||
.query_json_params(
|
||
"SELECT f_amount AS \"amount\" FROM it_main_num WHERE f_id = $1",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查主表失败");
|
||
assert_eq!(rows.len(), 1);
|
||
assert_eq!(
|
||
rows[0]["amount"],
|
||
json!(0.01),
|
||
"🔴 数值列应原样落库(没被转成文本或丢精度)"
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ② dry-run:生成 SQL 但**不落库**
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn dry_run_does_not_write_anything() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_dry").await;
|
||
|
||
let form = parse_form(&form_json("it_main_dry", "it_sub_dry"));
|
||
let model = parse_model(&model_json("it_main_dry", "it_sub_dry"));
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "C-303" }),
|
||
&mut c,
|
||
true,
|
||
)
|
||
.await
|
||
.expect("dry-run 应成功");
|
||
|
||
assert!(out.dry_run, "应标记为 dry-run");
|
||
assert!(out.statements > 0, "应生成 SQL");
|
||
|
||
let rows = db
|
||
.query_json("SELECT f_id FROM it_main_dry")
|
||
.await
|
||
.expect("查主表失败");
|
||
assert!(
|
||
rows.is_empty(),
|
||
"🔴 dry-run 不该落库,但查到了 {} 行",
|
||
rows.len()
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ③ 更新:子表差集对账(改一行 / 加一行 / 删一行)
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn update_reconciles_sub_table_diff() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_u").await;
|
||
create_sub_table(db, "it_sub_u").await;
|
||
|
||
let form = parse_form(&form_json("it_main_u", "it_sub_u"));
|
||
let model = parse_model(&model_json("it_main_u", "it_sub_u"));
|
||
|
||
// 先新增 2 行
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "D-404",
|
||
"tableField1": [
|
||
{ "F_Month": "2026-10", "F_Rent": 100 },
|
||
{ "F_Month": "2026-11", "F_Rent": 200 }
|
||
]
|
||
}),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
// 取旧的两行主键
|
||
let old = db
|
||
.query_json_params(
|
||
"SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_u \
|
||
WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(old.len(), 2);
|
||
let keep_id = old[0]["id"].as_str().unwrap().to_string(); // 2026-10 保留
|
||
let drop_id = old[1]["id"].as_str().unwrap().to_string(); // 2026-11 删掉
|
||
|
||
// 更新:保留第 1 行(改租金)、删掉第 2 行、加第 3 行
|
||
let mut c2 = ctx();
|
||
let up = update_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "D-405",
|
||
"tableField1": [
|
||
{ "f_id": keep_id, "F_Month": "2026-10", "F_Rent": 150 },
|
||
{ "F_Month": "2026-12", "F_Rent": 300 }
|
||
]
|
||
}),
|
||
&mut c2,
|
||
&out.id,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("更新应成功");
|
||
|
||
// 主表改了
|
||
let main = db
|
||
.query_json_params(
|
||
"SELECT f_room AS \"room\" FROM it_main_u WHERE f_id = $1",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查主表失败");
|
||
assert_eq!(main[0]["room"], json!("D-405"), "主表应被更新");
|
||
|
||
// 子表差集:留 1 行、删 1 行、加 1 行 ⇒ 共 2 行
|
||
let after = db
|
||
.query_json_params(
|
||
"SELECT f_month AS \"month\", f_rent AS \"rent\" FROM it_sub_u \
|
||
WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(
|
||
after.len(),
|
||
2,
|
||
"🔴 差集对账后应剩 2 行(留 1 加 1 删 1): {after:?}"
|
||
);
|
||
assert_eq!(after[0]["month"], json!("2026-10"));
|
||
assert_eq!(after[0]["rent"], json!(150.0), "保留的行应被更新");
|
||
assert_eq!(after[1]["month"], json!("2026-12"), "新增的行应在");
|
||
|
||
// 被删的行确实没了
|
||
let gone = db
|
||
.query_json_params(
|
||
"SELECT f_id FROM it_sub_u WHERE f_id = $1",
|
||
&[&drop_id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert!(gone.is_empty(), "🔴 缺失的旧行应被删除(物理删)");
|
||
let _ = up;
|
||
}
|
||
|
||
// ============================================================
|
||
// ④ 删除:主表 + 子表
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn delete_removes_main_and_sub_rows() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_d").await;
|
||
create_sub_table(db, "it_sub_d").await;
|
||
|
||
let form = parse_form(&form_json("it_main_d", "it_sub_d"));
|
||
let model = parse_model(&model_json("it_main_d", "it_sub_d"));
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "E-505",
|
||
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 100 } ]
|
||
}),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
let mut c2 = ctx();
|
||
delete_record(db, &form, &model, &mut c2, &out.id, false)
|
||
.await
|
||
.expect("删除应成功");
|
||
|
||
let main = db
|
||
.query_json_params("SELECT f_id FROM it_main_d WHERE f_id = $1", &[&out.id])
|
||
.await
|
||
.expect("查主表失败");
|
||
assert!(main.is_empty(), "🔴 主表行应被删除");
|
||
|
||
let subs = db
|
||
.query_json_params(
|
||
"SELECT f_id FROM it_sub_d WHERE f_receivableid = $1",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert!(subs.is_empty(), "🔴 子表行应被删除(不能留孤儿)");
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑤ 列不一致:设计稿有、真实库没有 ⇒ 拒绝写
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn column_mismatch_is_rejected_before_writing() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
// 故意少建一列:f_company_name
|
||
db.exec(
|
||
"CREATE TABLE it_main_m (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_room VARCHAR(100),
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
PRIMARY KEY (f_id)
|
||
)",
|
||
)
|
||
.await
|
||
.expect("建表失败");
|
||
|
||
let form = parse_form(&form_json("it_main_m", "it_sub_m"));
|
||
let model = parse_model(&model_json("it_main_m", "it_sub_m"));
|
||
|
||
let mut c = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "F-606" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("🔴 真实库缺列时必须拒绝写");
|
||
|
||
assert_eq!(
|
||
err.code,
|
||
"COLUMN_MISMATCH",
|
||
"应报列不一致: {}",
|
||
err.message
|
||
);
|
||
|
||
// 🔴 拒绝 ⇒ 一行都不能写进去
|
||
let rows = db
|
||
.query_json("SELECT f_id FROM it_main_m")
|
||
.await
|
||
.expect("查主表失败");
|
||
assert!(
|
||
rows.is_empty(),
|
||
"🔴 拒绝写入后表里不该有数据,但有 {} 行",
|
||
rows.len()
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑥ 事务回滚:中途失败不留孤儿行
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn failure_leaves_no_orphan_rows() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
// 主表有 f_room,子表**没有** f_rent ⇒ 子表 INSERT 会失败
|
||
db.exec(
|
||
"CREATE TABLE it_main_t (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_room VARCHAR(100),
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
PRIMARY KEY (f_id)
|
||
)",
|
||
)
|
||
.await
|
||
.expect("建主表失败");
|
||
db.exec(
|
||
"CREATE TABLE it_sub_t (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_receivableid VARCHAR(50),
|
||
f_month VARCHAR(20),
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
PRIMARY KEY (f_id)
|
||
)",
|
||
)
|
||
.await
|
||
.expect("建子表失败");
|
||
|
||
let form = parse_form(&form_json("it_main_t", "it_sub_t"));
|
||
let model = parse_model(&model_json("it_main_t", "it_sub_t"));
|
||
|
||
let mut c = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "G-707",
|
||
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 100 } ]
|
||
}),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("子表缺列时应失败");
|
||
|
||
// 两种可能:列校验阶段就拦下(COLUMN_MISMATCH),
|
||
// 或者执行阶段炸了(DB_ERROR)—— 都算「拒绝了这次写入」。
|
||
assert!(
|
||
err.code == "COLUMN_MISMATCH" || err.code == "DB_ERROR",
|
||
"应报结构化错误,实际: {} / {}",
|
||
err.code,
|
||
err.message
|
||
);
|
||
|
||
// 🔴 关键:主表也不能留下行(一个事务,要么全成要么全不成)
|
||
let main = db
|
||
.query_json("SELECT f_id FROM it_main_t")
|
||
.await
|
||
.expect("查主表失败");
|
||
assert!(
|
||
main.is_empty(),
|
||
"🔴 事务回滚后主表不该有孤儿行,但有 {} 行: {main:?}",
|
||
main.len()
|
||
);
|
||
let subs = db
|
||
.query_json("SELECT f_id FROM it_sub_t")
|
||
.await
|
||
.expect("查子表失败");
|
||
assert!(
|
||
subs.is_empty(),
|
||
"🔴 事务回滚后子表不该有孤儿行,但有 {} 行: {subs:?}",
|
||
subs.len()
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑦ 表不存在
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn missing_table_is_reported_clearly() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
|
||
let form = parse_form(&form_json("it_missing_main", "it_missing_sub"));
|
||
let model = parse_model(&model_json("it_missing_main", "it_missing_sub"));
|
||
|
||
let mut c = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "H-808" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("表不存在时应报错");
|
||
|
||
assert_eq!(
|
||
err.code,
|
||
"TABLE_NOT_IN_DB",
|
||
"应报表不存在: {}",
|
||
err.message
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑧ 更新不存在的记录
|
||
// ============================================================
|
||
|
||
#[tokio::test]
|
||
async fn update_of_missing_record_is_rejected() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_nu").await;
|
||
|
||
let form = parse_form(&form_json("it_main_nu", "it_sub_nu"));
|
||
let model = parse_model(&model_json("it_main_nu", "it_sub_nu"));
|
||
|
||
let mut c = ctx();
|
||
let err = update_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "I-909" }),
|
||
&mut c,
|
||
"no-such-id",
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("更新不存在的记录应报错");
|
||
|
||
assert!(
|
||
err.code.starts_with("RECORD") || err.code == "NOT_FOUND",
|
||
"应报记录不存在,实际: {} / {}",
|
||
err.code,
|
||
err.message
|
||
);
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑨ 唯一性校验:重复值必须被拦下(且一条都不能写进去)
|
||
// ============================================================
|
||
|
||
/// 🔴 带唯一性的表单(`F_Room` 标了 `unique`,`F_Code` 是业务主键)。
|
||
fn unique_form_json(main: &str) -> String {
|
||
json!({
|
||
"formRef": "formRef",
|
||
"formModel": "formData",
|
||
"logicalDelete": true,
|
||
"useBusinessKey": true,
|
||
"businessKeyList": ["F_Code"],
|
||
"businessKeyTip": "业务编码已存在",
|
||
"fields": [
|
||
{
|
||
"__vModel__": "F_Room",
|
||
"__config__": {
|
||
"jnpfKey": "input", "label": "房间号", "layout": "colFormItem",
|
||
"tableName": main, "required": true, "unique": true
|
||
}
|
||
},
|
||
{
|
||
"__vModel__": "F_Code",
|
||
"__config__": {
|
||
"jnpfKey": "input", "label": "业务编码", "layout": "colFormItem",
|
||
"tableName": main, "required": true
|
||
}
|
||
}
|
||
]
|
||
})
|
||
.to_string()
|
||
}
|
||
|
||
/// 模型:主表 + 唯一字段 + 业务主键字段 + 删除标记。
|
||
fn unique_model_json(main: &str) -> String {
|
||
json!([
|
||
{
|
||
"table": main, "tableName": "主表", "typeId": "1",
|
||
"fields": [
|
||
{ "field": "F_Id", "columnName": null, "dataType": "varchar", "primaryKey": 1 },
|
||
{ "field": "F_Room", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Code", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_CreatorTime", "columnName": null, "dataType": "datetime" },
|
||
{ "field": "F_CreatorUserId", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_LastModifyTime", "columnName": null, "dataType": "datetime" },
|
||
{ "field": "F_LastModifyUserId", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "f_tenant_id", "columnName": null, "dataType": "varchar", "primaryKey": 1 },
|
||
{ "field": "f_flow_task_id", "columnName": null, "dataType": "varchar" },
|
||
{ "field": "F_Delete_Mark", "columnName": null, "dataType": "int4" }
|
||
]
|
||
}
|
||
])
|
||
.to_string()
|
||
}
|
||
|
||
/// 主表(带删除标记列 —— 逻辑删除的行不参与判重)。
|
||
async fn create_main_table_with_delete_mark(db: &Db, table: &str) {
|
||
db.exec(&format!(
|
||
"CREATE TABLE {table} (
|
||
f_id VARCHAR(50) NOT NULL,
|
||
f_room VARCHAR(100),
|
||
f_code VARCHAR(100),
|
||
f_creatortime TIMESTAMP(0) WITHOUT TIME ZONE,
|
||
f_creatoruserid VARCHAR(50),
|
||
f_lastmodifytime TIMESTAMP(0) WITHOUT TIME ZONE,
|
||
f_lastmodifyuserid VARCHAR(50),
|
||
f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL,
|
||
f_flow_task_id VARCHAR(50),
|
||
f_delete_mark INTEGER,
|
||
PRIMARY KEY (f_id)
|
||
)"
|
||
))
|
||
.await
|
||
.expect("建主表失败");
|
||
}
|
||
|
||
/// 🔴 唯一字段重复 ⇒ 必须拒绝,且**一条都不能写进去**。
|
||
#[tokio::test]
|
||
async fn duplicate_unique_value_is_rejected() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table_with_delete_mark(db, "it_main_uniq").await;
|
||
|
||
let form = parse_form(&unique_form_json("it_main_uniq"));
|
||
let model = parse_model(&unique_model_json("it_main_uniq"));
|
||
|
||
// 第一条:房间号 X-1
|
||
let mut c = ctx();
|
||
insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "X-1", "F_Code": "CODE-1" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("第一条应成功");
|
||
|
||
// 第二条:房间号一样 ⇒ 唯一冲突
|
||
let mut c2 = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "X-1", "F_Code": "CODE-2" }),
|
||
&mut c2,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("🔴 重复的唯一值必须被拒绝");
|
||
|
||
assert_eq!(
|
||
err.code, "UNIQUE_CONSTRAINT_VIOLATED",
|
||
"应报唯一性冲突: {}",
|
||
err.message
|
||
);
|
||
|
||
// 🔴 拒绝 ⇒ 库里还是只有 1 行
|
||
let rows = db
|
||
.query_json("SELECT f_id, f_room FROM it_main_uniq")
|
||
.await
|
||
.expect("查主表失败");
|
||
assert_eq!(
|
||
rows.len(),
|
||
1,
|
||
"🔴 被拒的写入不该进库,但有 {} 行: {rows:?}",
|
||
rows.len()
|
||
);
|
||
}
|
||
|
||
/// 🔴 更新时改别的字段,**不能**被自己的唯一值判成冲突(要排除自己)。
|
||
#[tokio::test]
|
||
async fn update_excludes_itself_from_unique_check() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table_with_delete_mark(db, "it_main_uniq2").await;
|
||
|
||
let form = parse_form(&unique_form_json("it_main_uniq2"));
|
||
let model = parse_model(&unique_model_json("it_main_uniq2"));
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "Y-1", "F_Code": "CODE-Y" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
// 只改业务编码,唯一字段(房间号)原样带回去 ⇒ 不该冲突
|
||
let mut c2 = ctx();
|
||
update_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "Y-1", "F_Code": "CODE-Y2" }),
|
||
&mut c2,
|
||
&out.id,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("🔴 更新自己不该被判唯一冲突");
|
||
|
||
// 但改成别人的房间号 ⇒ 冲突
|
||
db.exec("INSERT INTO it_main_uniq2 (f_id, f_room, f_code) VALUES ('other', 'Y-2', 'CODE-Z')")
|
||
.await
|
||
.expect("插入对照行失败");
|
||
|
||
let mut c3 = ctx();
|
||
let err = update_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "Y-2", "F_Code": "CODE-Y3" }),
|
||
&mut c3,
|
||
&out.id,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("🔴 改成别人已占的room号必须被拒绝");
|
||
|
||
assert_eq!(err.code, "UNIQUE_CONSTRAINT_VIOLATED");
|
||
}
|
||
|
||
/// 🔴 业务主键(组合)重复 ⇒ 必须被拒绝。
|
||
#[tokio::test]
|
||
async fn duplicate_business_key_is_rejected() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table_with_delete_mark(db, "it_main_bk").await;
|
||
|
||
// 🔴 业务主键字段 F_Code 不是 unique 字段 ⇒ 唯一校验不会拦它,
|
||
// 必须由业务主键校验单独拦。
|
||
let form = parse_form(&unique_form_json("it_main_bk"));
|
||
let model = parse_model(&unique_model_json("it_main_bk"));
|
||
|
||
let mut c = ctx();
|
||
insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "Z-1", "F_Code": "BK-1" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("第一条应成功");
|
||
|
||
let mut c2 = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "Z-2", "F_Code": "BK-1" }),
|
||
&mut c2,
|
||
false,
|
||
)
|
||
.await
|
||
.expect_err("🔴 重复的业务主键必须被拒绝");
|
||
|
||
assert_eq!(
|
||
err.code, "BUSINESS_KEY_VIOLATED",
|
||
"应报业务主键冲突: {}",
|
||
err.message
|
||
);
|
||
assert!(
|
||
err.message.contains("业务编码已存在"),
|
||
"🔴 应使用设计稿里的 businessKeyTip 文案: {}",
|
||
err.message
|
||
);
|
||
|
||
let rows = db
|
||
.query_json("SELECT f_id FROM it_main_bk")
|
||
.await
|
||
.expect("查主表失败");
|
||
assert_eq!(rows.len(), 1, "🔴 被拒的写入不该进库");
|
||
}
|
||
|
||
/// 🔴 **dry-run 也要做业务校验** —— dry-run 的意义是「先看会不会被拦」。
|
||
#[tokio::test]
|
||
async fn dry_run_also_reports_unique_conflict() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table_with_delete_mark(db, "it_main_uniq3").await;
|
||
|
||
let form = parse_form(&unique_form_json("it_main_uniq3"));
|
||
let model = parse_model(&unique_model_json("it_main_uniq3"));
|
||
|
||
let mut c = ctx();
|
||
insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "W-1", "F_Code": "CODE-W" }),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("第一条应成功");
|
||
|
||
let mut c2 = ctx();
|
||
let err = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({ "F_Room": "W-1", "F_Code": "CODE-W2" }),
|
||
&mut c2,
|
||
true,
|
||
)
|
||
.await
|
||
.expect_err("🔴 dry-run 也必须报唯一冲突(否则 AI 会以为能落库)");
|
||
|
||
assert_eq!(err.code, "UNIQUE_CONSTRAINT_VIOLATED");
|
||
}
|
||
|
||
// ============================================================
|
||
// ⑩ only_update:只更新不删除(基线的 Excel 导入 / 流程场景)
|
||
// ============================================================
|
||
|
||
/// 🔴 `only_update = true` ⇒ 入参里缺失的旧行**不删**。
|
||
///
|
||
/// 基线平台 `FlowFormDataUtil.updateTable()`:
|
||
/// ```java
|
||
/// if (CollUtil.isNotEmpty(deleteList) && !onlyUpdate) { /* 删缺失的旧行 */ }
|
||
/// ```
|
||
#[tokio::test]
|
||
async fn only_update_keeps_missing_old_rows() {
|
||
let _g = LOCK.lock().await;
|
||
let db = db().await;
|
||
create_main_table(db, "it_main_ou").await;
|
||
create_sub_table(db, "it_sub_ou").await;
|
||
|
||
let form = parse_form(&form_json("it_main_ou", "it_sub_ou"));
|
||
let model = parse_model(&model_json("it_main_ou", "it_sub_ou"));
|
||
|
||
let mut c = ctx();
|
||
let out = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "OU-1",
|
||
"tableField1": [
|
||
{ "F_Month": "2026-10", "F_Rent": 100 },
|
||
{ "F_Month": "2026-11", "F_Rent": 200 }
|
||
]
|
||
}),
|
||
&mut c,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
let old = db
|
||
.query_json_params(
|
||
"SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_ou \
|
||
WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(old.len(), 2);
|
||
let keep_id = old[0]["id"].as_str().unwrap().to_string();
|
||
|
||
// 只传 1 行 ⇒ 默认(only_update=false)会删掉另一行
|
||
let mut c2 = ctx();
|
||
update_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "OU-1",
|
||
"tableField1": [ { "f_id": keep_id, "F_Month": "2026-10", "F_Rent": 150 } ]
|
||
}),
|
||
&mut c2,
|
||
&out.id,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("更新应成功");
|
||
|
||
let after_default = db
|
||
.query_json_params(
|
||
"SELECT f_month AS \"month\" FROM it_sub_ou WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(
|
||
after_default.len(),
|
||
1,
|
||
"🔴 默认行为(only_update=false)应删掉缺失的旧行: {after_default:?}"
|
||
);
|
||
|
||
// 再造一条数据,用 only_update=true 更新 ⇒ 旧行应保留
|
||
let mut c3 = ctx();
|
||
let out2 = insert_record(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "OU-2",
|
||
"tableField1": [
|
||
{ "F_Month": "2026-10", "F_Rent": 100 },
|
||
{ "F_Month": "2026-11", "F_Rent": 200 }
|
||
]
|
||
}),
|
||
&mut c3,
|
||
false,
|
||
)
|
||
.await
|
||
.expect("新增应成功");
|
||
|
||
let old2 = db
|
||
.query_json_params(
|
||
"SELECT f_id AS \"id\", f_month AS \"month\" FROM it_sub_ou \
|
||
WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out2.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
let keep2 = old2[0]["id"].as_str().unwrap().to_string();
|
||
|
||
let mut c4 = ctx();
|
||
ssw_platform::lowcode_crud::update_record_with(
|
||
db,
|
||
&form,
|
||
&model,
|
||
&json!({
|
||
"F_Room": "OU-2",
|
||
"tableField1": [ { "f_id": keep2, "F_Month": "2026-10", "F_Rent": 180 } ]
|
||
}),
|
||
&mut c4,
|
||
&out2.id,
|
||
false,
|
||
true,
|
||
)
|
||
.await
|
||
.expect("only_update 更新应成功");
|
||
|
||
let after_only = db
|
||
.query_json_params(
|
||
"SELECT f_month AS \"month\", f_rent AS \"rent\" FROM it_sub_ou \
|
||
WHERE f_receivableid = $1 ORDER BY f_month",
|
||
&[&out2.id],
|
||
)
|
||
.await
|
||
.expect("查子表失败");
|
||
assert_eq!(
|
||
after_only.len(),
|
||
2,
|
||
"🔴 only_update=true 时缺失的旧行应保留: {after_only:?}"
|
||
);
|
||
assert_eq!(after_only[0]["rent"], json!(180.0), "传进来的那行应被更新");
|
||
assert_eq!(after_only[1]["month"], json!("2026-11"), "没传的旧行应原样保留");
|
||
}
|
||
|
||
|