Files
ssw-platform/crates/tests/tests/lowcode_crud_it.rs
T
admin acf076df5a refactor: 内核瘦身 —— 示例搬成业务包 + 装配/测试各归其位
- 内核只有 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。
2026-11-04 14:46:12 +08:00

1134 lines
35 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.
//! 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"), "没传的旧行应原样保留");
}