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 注释)
This commit is contained in:
admin committed 2026-10-31 19:26:47 +08:00
1 parent 343772be42
commit bcbe46c92b
23 files changed
+11185 -26

No files matched your search

File diff suppressed because it is too large. Load diff
+752
View File
@@ -0,0 +1,752 @@
//! lowcode_ddl 集成测试 —— **真实 pglite 库**上的「生成 DDL → 建表 → 回写模型 → 动态 CRUD」闭环。
//!
//! ## 🔴 为什么这是 P2-b 最关键的一组测试
//!
//! 前面各层分别证明:
//!
//! | 层 | 证明什么 |
//! |---|---|
//! | `sspf-lowcode` 的单测 | DDL 文本**长得对** |
//! | `sspf-lowcode` 的 `real_ddl` | DDL 与**官方真实 DDL**同形 |
//! | `lowcode_crud_it` | CRUD 在**手写的表**上能跑 |
//!
//! 但**没有任何一组**证明:「用生成器建的表」和「CRUD 用的模型」是**同一套**。
//!
//! 这一组补上最后一环:
//!
//! ```text
//! 模型(fixture)
//! ├─ plan_create() ──▶ CREATE TABLE ──▶ 真库建表
//! ├─ rewrite_model() ▶ 回写后的模型(含系统列)
//! └─ plan_insert() ──▶ INSERT ... ──▶ 真库写入(用回写后的模型)
//! ```
//!
//! ## 🔴 这组测试能抓到的真实 bug(已经抓到过两个)
//!
//! | Bug | 现象 |
//! |---|---|
//! | `f_delete_mark` 写成 boolean | PG 报 `invalid input syntax for type integer: "true"` |
//! | **建表后不回写模型** | 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED`(真实库明明有删除列) |
//! | 主键不是复合的 | 生成器建的主键与 CRUD 假设的主键不一致 |
//! | 子表外键列名不一致 | `column "f_receivableid" does not exist` |
//! | 系统列重复追加 | `column "f_tenant_id" specified more than once` |
//! | 类型映射错(decimal→text) | 数值列存成文本,排序错乱 |
//!
//! ## 🔴 pglite 是进程级单例 ⇒ 全文件串行 + 每测试专属表名
//!
//! 与 `lowcode_crud_it` 同款:`OnceCell` + 进程级 `Mutex`。
//! **表名必须每个测试都不一样** —— 全文件共用一个库,
//! 而且不同测试要不同的表结构(有的带删除列、有的不带)。
use serde_json::json;
use sspf_lowcode::{plan_create, rewrite_model, DdlOptions, FormSchema, ModelSchema};
use ssw_platform::lowcode_crud::{
build_context, delete_record, insert_record, now_iso, DEFAULT_TENANT_ID,
};
use ssw_platform::platform::db::Db;
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 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
db
})
.await
}
// ============================================================
// 官方 fixture(与基线平台初始化 SQL 同源)
// ============================================================
/// 生成一份带指定表名的官方模型。
fn official_model(main: &str, sub: &str) -> String {
format!(
r#"[
{{
"table": "{main}", "tableName": "应收费用主表", "typeId": "1",
"tableField": "", "relationField": "", "relationTable": "",
"fields": [
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
{{ "field": "F_Building", "fieldName": "楼宇号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Room", "fieldName": "房间号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Company_name", "fieldName": "公司名称", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Sort_Code", "fieldName": "排序", "dataType": "bigint", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_EnabledMark", "fieldName": "有效标志", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_CreatorTime", "fieldName": "创建时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_CreatorUserId", "fieldName": "创建用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_LastModifyTime", "fieldName": "最后修改时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_LastModifyUserId", "fieldName": "最后修改用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "f_tenant_id", "fieldName": "租户id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
{{ "field": "f_version", "fieldName": "乐观锁", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "f_flow_task_id", "fieldName": "流程任务主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "f_flow_state", "fieldName": "流程任务状态", "dataType": "int", "dataLength": null, "primaryKey": 0, "allowNull": 1 }}
]
}},
{{
"table": "{sub}", "tableName": "应收费用明细表", "typeId": "0",
"tableField": "F_Receivableid", "relationField": "F_Id", "relationTable": "{main}",
"fields": [
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
{{ "field": "F_Receivableid", "fieldName": "主表id", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Month", "fieldName": "缴费月份", "dataType": "varchar", "dataLength": "200", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Rent", "fieldName": "房租", "dataType": "decimal", "dataLength": "18,2", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Totalbilling", "fieldName": "累计应收费用", "dataType": "decimal", "dataLength": "18,2", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_CreatorTime", "fieldName": "创建时间", "dataType": "datetime", "dataLength": null, "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_CreatorUserId", "fieldName": "创建用户", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "f_tenant_id", "fieldName": "租户id", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }}
]
}}
]"#
)
}
/// 生成一份带指定表名的表单。
fn official_form(main: &str, sub: &str) -> String {
format!(
r#"{{
"formRef": "formRef", "formModel": "formData",
"primaryKeyPolicy": 1, "concurrencyLock": false, "logicalDelete": false,
"fields": [
{{ "__vModel__": "F_Building", "__config__": {{ "jnpfKey": "input", "label": "楼宇号", "layout": "colFormItem", "tableName": "{main}" }} }},
{{ "__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__": "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" }} }}
]
}}
]
}}"#
)
}
fn model_of(main: &str, sub: &str) -> ModelSchema {
ModelSchema::from_str(&official_model(main, sub)).expect("模型应可解析")
}
fn form_of(main: &str, sub: &str) -> FormSchema {
FormSchema::from_str(&official_form(main, sub)).expect("表单应可解析")
}
/// 逻辑删除的表单(`logicalDelete = true`)。
fn logical_form_of(main: &str, sub: &str) -> FormSchema {
let v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
let mut obj = v.as_object().unwrap().clone();
obj.insert("logicalDelete".to_string(), serde_json::Value::Bool(true));
FormSchema::parse(&serde_json::Value::Object(obj)).expect("表单应可解析")
}
/// 房间号标唯一 + 逻辑删除的表单。
fn unique_logical_form_of(main: &str, sub: &str) -> FormSchema {
let mut v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
{
let obj = v.as_object_mut().unwrap();
obj.insert("logicalDelete".to_string(), serde_json::Value::Bool(true));
obj.insert("useBusinessKey".to_string(), serde_json::Value::Bool(false));
if let Some(fields) = obj.get_mut("fields").and_then(|f| f.as_array_mut()) {
for f in fields.iter_mut() {
let vm = f.get("__vModel__").and_then(|v| v.as_str()).unwrap_or("");
if vm == "F_Room" {
f.get_mut("__config__")
.and_then(|c| c.as_object_mut())
.unwrap()
.insert("unique".to_string(), serde_json::Value::Bool(true));
}
}
}
}
FormSchema::parse(&v).expect("表单应可解析")
}
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
}
/// 🔴 用 DDL 生成器把表建出来,**并回写模型**(含系统列)。
///
/// ## 为什么必须回写
///
/// 基线平台 `VisualDevTableCre.tableList()` 建完表后会用**建表清单**
/// 重新组装 `TableModel` 再写回 `f_tables_data` ⇒ 建表后的模型**含系统列**。
///
/// 不回写的后果(本项目已真实踩到):
/// 逻辑删除报 `LOGICAL_DELETE_UNSUPPORTED` —— CRUD 层在**模型**里找
/// `f_delete_mark`,找不到就报错,尽管真实库里明明有这一列。
///
/// ⇒ 返回**回写后的**模型,CRUD 用它跑 —— 这才是真实闭环。
async fn create_tables(db: &Db, model: &ModelSchema, opts: &DdlOptions) -> ModelSchema {
let plan = plan_create(model, opts).expect("应能生成建表计划");
for sql in plan.render() {
db.exec(&sql).await.unwrap_or_else(|e| panic!("建表失败: {e}\n{sql}"));
}
// 🔴 回写模型(建表后的真实表结构)。
let rewritten = rewrite_model(model, &plan);
ModelSchema::parse(&rewritten).expect("回写后的模型应可解析")
}
/// 表是否已存在。
async fn table_exists(db: &Db, table: &str) -> bool {
let rows = db
.query_json_params(
"SELECT 1 AS \"x\" FROM information_schema.tables \
WHERE table_name = $1 LIMIT 1",
&[&table.to_string()],
)
.await
.expect("查表失败");
!rows.is_empty()
}
// ============================================================
// ① 生成的 DDL 真能在 pglite 上建表
// ============================================================
#[tokio::test]
async fn generated_ddl_creates_real_tables() {
let _g = LOCK.lock().await;
let db = db().await;
let opts = DdlOptions::default_options();
create_tables(
db,
&model_of("sspf_ddl_a_main", "sspf_ddl_a_sub"),
&opts,
)
.await;
assert!(
table_exists(db, "sspf_ddl_a_main").await,
"主表应建出来"
);
assert!(
table_exists(db, "sspf_ddl_a_sub").await,
"子表应建出来"
);
}
/// 🔴 真实库里的列必须与生成器说的一致。
#[tokio::test]
async fn real_columns_match_generated_ddl() {
let _g = LOCK.lock().await;
let db = db().await;
let opts = DdlOptions::default_options();
let model = model_of("sspf_ddl_b_main", "sspf_ddl_b_sub");
create_tables(db, &model, &opts).await;
let plan = plan_create(&model, &opts).expect("应能生成建表计划");
for t in plan.all() {
let rows = db
.query_json_params(
"SELECT column_name AS \"name\" FROM information_schema.columns \
WHERE table_name = $1 ORDER BY ordinal_position",
&[&t.table],
)
.await
.expect("查列失败");
let real: Vec<String> = rows
.iter()
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
.collect();
let expected = t.column_names();
assert_eq!(
real, expected,
"🔴 表 {} 的真实列与生成器不一致",
t.table
);
}
}
/// 🔴 主键必须是**复合**的 `(f_id, f_tenant_id)`。
#[tokio::test]
async fn real_primary_key_is_composite() {
let _g = LOCK.lock().await;
let db = db().await;
let opts = DdlOptions::default_options();
create_tables(
db,
&model_of("sspf_ddl_c_main", "sspf_ddl_c_sub"),
&opts,
)
.await;
let rows = db
.query_json_params(
"SELECT a.attname AS \"name\" \
FROM pg_index i \
JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey) \
WHERE i.indrelid = 'sspf_ddl_c_main'::regclass AND i.indisprimary \
ORDER BY a.attnum",
&[],
)
.await
.expect("查主键失败");
let pks: Vec<String> = rows
.iter()
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
.collect();
assert_eq!(
pks,
vec!["f_id".to_string(), "f_tenant_id".to_string()],
"🔴 官方真实 DDL 的主键是复合的 (f_id, f_tenant_id)"
);
}
/// 🔴 **回写后的模型**必须与真实库的列**完全一致**。
///
/// 这是「设计稿 ↔ 真实库」一致性的核心断言:
/// 回写没做(或做错了)⇒ 模型少列 ⇒ 动态 CRUD 找不到删除列。
#[tokio::test]
async fn rewritten_model_matches_real_columns() {
let _g = LOCK.lock().await;
let db = db().await;
let mut opts = DdlOptions::default_options();
opts.logical_delete = true;
let model = model_of("sspf_ddl_k_main", "sspf_ddl_k_sub");
let rewritten = create_tables(db, &model, &opts).await;
for t in rewritten.tables.iter() {
let rows = db
.query_json_params(
"SELECT column_name AS \"name\" FROM information_schema.columns \
WHERE table_name = $1 ORDER BY ordinal_position",
&[&t.table],
)
.await
.expect("查列失败");
let real: Vec<String> = rows
.iter()
.map(|r| r["name"].as_str().unwrap_or_default().to_string())
.collect();
assert_eq!(
real,
t.column_names(),
"🔴 表 {} 的回写模型与真实库列不一致",
t.table
);
}
}
// ============================================================
// ② 用生成器建的表,跑真实 CRUD
// ============================================================
/// 🔴 端到端:建表 → 回写模型 → 新增(主表 + 子表)→ 数据真落库。
#[tokio::test]
async fn crud_runs_on_generated_tables() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_d_main", "sspf_ddl_d_sub");
let opts = DdlOptions::default_options();
// 🔴 用**回写后的**模型跑 CRUD(真实闭环)。
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = form_of(main, sub);
let mut c = ctx();
let out = insert_record(
db,
&form,
&model,
&json!({
"F_Building": "A 栋",
"F_Room": "A-101",
"F_Company_name": "某某公司",
"tableField1": [
{ "F_Month": "2026-10", "F_Rent": 100.5 },
{ "F_Month": "2026-11", "F_Rent": 200.25 }
]
}),
&mut c,
false,
)
.await
.expect("新增应成功");
assert_eq!(out.statements, 3, "1 主表 + 2 子表");
let rows = db
.query_json_params(
"SELECT f_room AS \"room\", f_company_name AS \"company\", \
f_tenant_id AS \"tenant\" FROM sspf_ddl_d_main 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]["company"], json!("某某公司"));
assert_eq!(rows[0]["tenant"], json!(DEFAULT_TENANT_ID));
// 子表外键列是 `f_receivableid`(**不是** `f_foreign_id`)
let subs = db
.query_json_params(
"SELECT f_month AS \"month\", f_rent AS \"rent\", f_receivableid AS \"fk\" \
FROM sspf_ddl_d_sub 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()));
}
/// 🔴 **decimal 列**必须真的存成数值(类型映射错 ⇒ 存成文本)。
#[tokio::test]
async fn decimal_columns_are_numeric_in_real_db() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_e_main", "sspf_ddl_e_sub");
let opts = DdlOptions::default_options();
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = form_of(main, sub);
let mut c = ctx();
let out = insert_record(
db,
&form,
&model,
&json!({
"F_Room": "B-202",
"tableField1": [ { "F_Month": "2026-10", "F_Rent": 1234.56 } ]
}),
&mut c,
false,
)
.await
.expect("新增应成功");
let rows = db
.query_json_params(
"SELECT f_rent AS \"rent\", pg_typeof(f_rent)::text AS \"typ\" \
FROM sspf_ddl_e_sub WHERE f_receivableid = $1",
&[&out.id],
)
.await
.expect("查子表失败");
assert_eq!(rows.len(), 1);
assert_eq!(rows[0]["rent"], json!(1234.56), "数值应原样落库");
assert_eq!(
rows[0]["typ"],
json!("numeric"),
"🔴 decimal 列的 PG 类型应是 numeric(映射错就会变 text)"
);
}
/// 🔴 **datetime 列**必须真的存成 timestamp。
///
/// ## 🔴 注意:创建时间**不会被自动写**
///
/// 官方 fixture 表单里**没有** `createTime` 控件,Java 也是**按表单控件**写列
/// (`FlowFormDataUtil.createMastTable()` 遍历 `mastForm`)。
/// ⇒ `f_creatortime` 是「建表时按模型建的列」,但**运行时没人往里写**。
///
/// 这不是 bug,是官方形态:只有表单里放了 `createTime` 控件的设计稿才会自动填。
/// 本测试验证的是**类型**(timestamp)以及「没控件就不写」这个口径。
#[tokio::test]
async fn datetime_columns_are_timestamp_in_real_db() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_f_main", "sspf_ddl_f_sub");
let opts = DdlOptions::default_options();
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = form_of(main, sub);
let mut c = ctx();
let out = insert_record(
db,
&form,
&model,
&json!({ "F_Room": "C-303" }),
&mut c,
false,
)
.await
.expect("新增应成功");
let rows = db
.query_json_params(
"SELECT pg_typeof(f_creatortime)::text AS \"typ\", f_creatortime AS \"t\" \
FROM sspf_ddl_f_main WHERE f_id = $1",
&[&out.id],
)
.await
.expect("查主表失败");
assert_eq!(
rows[0]["typ"],
json!("timestamp without time zone"),
"🔴 datetime 列的 PG 类型应是 timestamp"
);
assert!(
rows[0]["t"].is_null(),
"🔴 表单里没有 createTime 控件 ⇒ 创建时间不该被写(对齐 JNPF 的按控件写列)"
);
}
/// 🔴 表单里**有** `createTime` 控件 ⇒ 创建时间必须被自动写入。
///
/// 这与上一个测试互为对照:自动填充是**按控件**触发的,不是按列名。
#[tokio::test]
async fn create_time_is_filled_when_form_has_control() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_l_main", "sspf_ddl_l_sub");
let opts = DdlOptions::default_options();
let model = create_tables(db, &model_of(main, sub), &opts).await;
// 表单里加一个 `createTime` 控件(`F_CreatorTime`)
let mut v: serde_json::Value = serde_json::from_str(&official_form(main, sub)).unwrap();
{
let obj = v.as_object_mut().unwrap();
let fields = obj.get_mut("fields").and_then(|f| f.as_array_mut()).unwrap();
fields.push(json!({
"__vModel__": "F_CreatorTime",
"__config__": {
"jnpfKey": "createTime", "label": "创建时间",
"layout": "colFormItem", "tableName": main
}
}));
}
let form = FormSchema::parse(&v).expect("表单应可解析");
let mut c = ctx();
let out = insert_record(
db,
&form,
&model,
&json!({ "F_Room": "C-404" }),
&mut c,
false,
)
.await
.expect("新增应成功");
let rows = db
.query_json_params(
"SELECT f_creatortime AS \"t\" FROM sspf_ddl_l_main WHERE f_id = $1",
&[&out.id],
)
.await
.expect("查主表失败");
assert!(
!rows[0]["t"].is_null(),
"🔴 有 createTime 控件时创建时间必须被写入(AutoFill::Now)"
);
}
// ============================================================
// ③ 逻辑删除:🔴 抓 `f_delete_mark` 类型 bug 的那组测试
// ============================================================
/// 🔴 逻辑删除必须成功,且删除标记是 **1**(INTEGER 列)。
///
/// ## 这组测试抓到的真实 bug
///
/// `f_delete_mark` 在官方真实 DDL 里是 `INTEGER`(Java `TableFeildsEnum.DELETEMARK`
/// 的 dataType 也是 `"int"`),基线平台写的是 `equalTo(1)`。
///
/// 之前 Rust 侧写的是 `Value::Bool(true)` ⇒ 执行层转成字符串 `"true"`
/// ⇒ PG 直接报 `invalid input syntax for type integer: "true"`。
///
/// ## 🔴 第二个真实 bug:不回写模型
///
/// 建表加了删除列,但**模型里没有** ⇒ CRUD 层找不到 `f_delete_mark`
/// ⇒ 报 `LOGICAL_DELETE_UNSUPPORTED`。
/// 解法是 `rewrite_model()`:建表后把真实表结构回写进模型。
#[tokio::test]
async fn logical_delete_writes_integer_marker() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_g_main", "sspf_ddl_g_sub");
let mut opts = DdlOptions::default_options();
opts.logical_delete = true;
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = logical_form_of(main, sub);
let mut c = ctx();
let out = insert_record(
db,
&form,
&model,
&json!({
"F_Room": "D-404",
"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("🔴 逻辑删除应成功(写 integer 的删除标记)");
// 主表行还在,但删除标记 = 1
let rows = db
.query_json_params(
"SELECT f_delete_mark AS \"mark\", f_delete_time AS \"time\", \
f_delete_user_id AS \"user\" FROM sspf_ddl_g_main WHERE f_id = $1",
&[&out.id],
)
.await
.expect("查主表失败");
assert_eq!(rows.len(), 1, "🔴 逻辑删除后行应还在表里");
assert_eq!(
rows[0]["mark"],
json!(1),
"🔴 删除标记应是 1(f_delete_mark 是 INTEGER,不是 boolean)"
);
assert!(!rows[0]["time"].is_null(), "删除时间应被写入");
assert_eq!(rows[0]["user"], json!("u-1"), "删除人应被写入");
// 子表行也被逻辑删除
let subs = db
.query_json_params(
"SELECT f_delete_mark AS \"mark\" FROM sspf_ddl_g_sub WHERE f_receivableid = $1",
&[&out.id],
)
.await
.expect("查子表失败");
assert_eq!(subs.len(), 1);
assert_eq!(subs[0]["mark"], json!(1), "子表也该被逻辑删除");
}
/// 🔴 `logicalDelete = false` ⇒ **物理删除**(行真的消失)。
#[tokio::test]
async fn physical_delete_removes_rows_when_logical_is_off() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_h_main", "sspf_ddl_h_sub");
let opts = DdlOptions::default_options();
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = form_of(main, sub);
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 rows = db
.query_json_params(
"SELECT f_id FROM sspf_ddl_h_main WHERE f_id = $1",
&[&out.id],
)
.await
.expect("查主表失败");
assert!(rows.is_empty(), "🔴 物理删除后主表行应消失");
let subs = db
.query_json_params(
"SELECT f_id FROM sspf_ddl_h_sub WHERE f_receivableid = $1",
&[&out.id],
)
.await
.expect("查子表失败");
assert!(subs.is_empty(), "🔴 子表行也应消失(不能留孤儿)");
}
/// 🔴 `logicalDelete = true` 但表里**没有**删除列 ⇒ 必须报错,不许静默物理删。
///
/// 这是「设计稿与真实库不一致」的典型:模型说逻辑删除,但表是按
/// `logicalDelete = false` 建的。
#[tokio::test]
async fn logical_delete_on_table_without_marker_is_rejected() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_i_main", "sspf_ddl_i_sub");
// 按 logicalDelete = false 建表(没有删除列)
let opts = DdlOptions::default_options();
let model = create_tables(db, &model_of(main, sub), &opts).await;
let mut c = ctx();
let out = insert_record(
db,
&form_of(main, sub),
&model,
&json!({ "F_Room": "F-606" }),
&mut c,
false,
)
.await
.expect("新增应成功");
let mut c2 = ctx();
let err = delete_record(db, &logical_form_of(main, sub), &model, &mut c2, &out.id, false)
.await
.expect_err("🔴 表里没有删除列时,逻辑删除必须被拒");
assert_eq!(
err.code, "LOGICAL_DELETE_UNSUPPORTED",
"应报不支持逻辑删除: {}",
err.message
);
// 🔴 拒绝 ⇒ 行还在(不能被静默物理删)
let rows = db
.query_json_params(
"SELECT f_id FROM sspf_ddl_i_main WHERE f_id = $1",
&[&out.id],
)
.await
.expect("查主表失败");
assert_eq!(rows.len(), 1, "🔴 被拒的逻辑删除不该动数据");
}
/// 🔴 逻辑删除的行**不参与**唯一性判重(对齐 Java 的 `delete_mark IS NULL`)。
#[tokio::test]
async fn logically_deleted_rows_do_not_block_unique_values() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_ddl_j_main", "sspf_ddl_j_sub");
let mut opts = DdlOptions::default_options();
opts.logical_delete = true;
let model = create_tables(db, &model_of(main, sub), &opts).await;
let form = unique_logical_form_of(main, sub);
// 第一条:房间号 UNI-1
let mut c = ctx();
let out = insert_record(db, &form, &model, &json!({ "F_Room": "UNI-1" }), &mut c, false)
.await
.expect("第一条应成功");
// 逻辑删除它
let mut c2 = ctx();
delete_record(db, &form, &model, &mut c2, &out.id, false)
.await
.expect("逻辑删除应成功");
// 再插入同房间号 ⇒ 应该**能**成功(已删的行不占坑)
let mut c3 = ctx();
insert_record(db, &form, &model, &json!({ "F_Room": "UNI-1" }), &mut c3, false)
.await
.expect("🔴 已逻辑删除的行不该再占着唯一值");
}
+366
View File
@@ -0,0 +1,366 @@
//! 内核动态建表层的集成测试 —— **真实 pglite 库**。
//!
//! ## 覆盖什么
//!
//! | 测试 | 证明什么 |
//! |---|---|
//! | `create_tables_creates_real_tables` | 建表真的落到真实库 |
//! | `create_tables_is_idempotent` | 重复建表不报错(幂等),且模型照样回写 |
//! | `existing_table_with_different_columns_is_rejected` | 结构不符时报错,不硬改 |
//! | `create_and_sync_writes_back_model` | `f_tables_data` 被回写成含系统列的模型 |
//! | `model_after_write_back_matches_real_db` | 回写后的模型 ↔ 真实库列完全一致 |
//! | `dry_run_creates_nothing` | dry-run 不建表不回写 |
//! | `logical_delete_tables_get_delete_columns` | 逻辑删除 ⇒ 主表子表都有删除列 |
//!
//! ## 🔴 为什么单独一组
//!
//! `lowcode_ddl_it` 测的是 `sspf-lowcode` 的**纯计算**能力(DDL 文本 + 回写模型);
//! 这一组测的是**内核执行层**:真连库、真建表、真回写 `base_visual_dev`。
use serde_json::{json, Value};
use sspf_lowcode::{FormSchema, ModelSchema};
use ssw_platform::lowcode_ddl::{
create_and_sync, create_tables, preview_ddl, real_columns, table_exists, write_back_model,
};
use ssw_platform::platform::db::Db;
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 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
db
})
.await
}
/// 一份带指定表名的模型。
fn model_json(main: &str, sub: &str) -> String {
format!(
r#"[
{{
"table": "{main}", "tableName": "主表", "typeId": "1",
"tableField": "", "relationField": "", "relationTable": "",
"fields": [
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
{{ "field": "F_Room", "fieldName": "房间号", "dataType": "varchar", "dataLength": "100", "primaryKey": 0, "allowNull": 1 }}
]
}},
{{
"table": "{sub}", "tableName": "子表", "typeId": "0",
"tableField": "F_Receivableid", "relationField": "F_Id", "relationTable": "{main}",
"fields": [
{{ "field": "F_Id", "fieldName": "主键", "dataType": "varchar", "dataLength": "50", "primaryKey": 1, "allowNull": 0 }},
{{ "field": "F_Receivableid", "fieldName": "主表id", "dataType": "varchar", "dataLength": "50", "primaryKey": 0, "allowNull": 1 }},
{{ "field": "F_Month", "fieldName": "缴费月份", "dataType": "varchar", "dataLength": "200", "primaryKey": 0, "allowNull": 1 }}
]
}}
]"#
)
}
/// 一份带指定表名的表单。
fn form_json(main: &str, sub: &str, logical_delete: bool) -> String {
format!(
r#"{{
"formRef": "formRef", "formModel": "formData",
"primaryKeyPolicy": 1, "concurrencyLock": false, "logicalDelete": {logical_delete},
"fields": [
{{ "__vModel__": "F_Room", "__config__": {{ "jnpfKey": "input", "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" }} }}
]
}}
]
}}"#
)
}
fn model_of(main: &str, sub: &str) -> ModelSchema {
ModelSchema::from_str(&model_json(main, sub)).expect("模型应可解析")
}
fn form_of(main: &str, sub: &str, logical_delete: bool) -> FormSchema {
FormSchema::from_str(&form_json(main, sub, logical_delete)).expect("表单应可解析")
}
/// 🔴 往 `base_visual_dev` 插一条功能定义(回写的目标)。
async fn insert_visualdev(db: &Db, id: &str, en_code: &str, tables_data: &str) {
db.exec_params(
"INSERT INTO base_visual_dev \
(f_id, f_full_name, f_en_code, f_state, f_type, f_tables_data, f_form_data, f_column_data, f_tenant_id) \
VALUES ($1, $2, $3, 1, 1, $4, '', '', '0')",
&[
&id.to_string(),
&format!("{en_code} 功能"),
&en_code.to_string(),
&tables_data.to_string(),
],
)
.await
.expect("插 base_visual_dev 失败");
}
// ============================================================
// ① 建表真的落到真实库
// ============================================================
#[tokio::test]
async fn create_tables_creates_real_tables() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_a_main", "sspf_k_ddl_a_sub");
let out = create_tables(db, &model_of(main, sub), &form_of(main, sub, false), false)
.await
.expect("建表应成功");
assert_eq!(out.tables.len(), 2, "主表 + 子表");
assert!(out.skipped.is_empty());
assert!(table_exists(db, main).await.unwrap(), "主表应建出来");
assert!(table_exists(db, sub).await.unwrap(), "子表应建出来");
// DDL 应含复合主键
assert!(out.ddl[0].contains("PRIMARY KEY (f_id, f_tenant_id)"), "{}", out.ddl[0]);
}
// ============================================================
// ② 幂等
// ============================================================
/// 🔴 重复建表**不报错**(基线平台同款:`DbTableServiceImpl.createTable()` 存在就返回)。
#[tokio::test]
async fn create_tables_is_idempotent() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_b_main", "sspf_k_ddl_b_sub");
let model = model_of(main, sub);
let form = form_of(main, sub, false);
let first = create_tables(db, &model, &form, false).await.expect("首次建表");
assert_eq!(first.tables.len(), 2);
assert!(first.skipped.is_empty());
// 第二次 ⇒ 全部跳过,不报错
let second = create_tables(db, &model, &form, false)
.await
.expect("🔴 重复建表不该报错(幂等)");
assert!(second.tables.is_empty(), "第二次不该再建表");
assert_eq!(second.skipped.len(), 2, "两张表都该被跳过");
assert!(!second.notes.is_empty(), "该说明为什么跳过");
}
/// 🔴 表已存在但**列结构不同** ⇒ 报错,不硬改。
#[tokio::test]
async fn existing_table_with_different_columns_is_rejected() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_c_main", "sspf_k_ddl_c_sub");
// 先手建一张**列不一样**的表
db.exec(&format!(
"CREATE TABLE {main} (f_id VARCHAR(50) NOT NULL, f_other VARCHAR(10))"
))
.await
.expect("手建表失败");
let err = create_tables(db, &model_of(main, sub), &form_of(main, sub, false), false)
.await
.expect_err("🔴 结构不符必须报错");
assert_eq!(
err.code, "TABLE_EXISTS_DIFFERENT",
"应报结构不一致: {}",
err.message
);
// 错误要说清差在哪
assert!(err.message.contains("f_tenant_id"), "应指出缺哪列: {}", err.message);
}
// ============================================================
// ③ 回写 `f_tables_data`
// ============================================================
/// 🔴 建表 + 回写:`base_visual_dev.f_tables_data` 要变成**含系统列**的模型。
#[tokio::test]
async fn create_and_sync_writes_back_model() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_d_main", "sspf_k_ddl_d_sub");
let id = "vd_ddl_d";
insert_visualdev(db, id, "demoDdlD", &model_json(main, sub)).await;
let out = create_and_sync(
db,
id,
&model_of(main, sub),
&form_of(main, sub, false),
false,
)
.await
.expect("建表+回写应成功");
// 读回 `f_tables_data`
let rows = db
.query_json_params(
"SELECT COALESCE(f_tables_data,'') AS \"tablesData\" FROM base_visual_dev WHERE f_id = $1",
&[&id.to_string()],
)
.await
.expect("读 base_visual_dev 失败");
let text = rows[0]["tablesData"].as_str().unwrap_or_default();
assert!(!text.is_empty(), "回写后不该是空");
// 回写的模型应含系统列
let parsed: Value = serde_json::from_str(text).expect("回写内容应是合法 JSON");
let m = ModelSchema::parse(&parsed).expect("回写内容应是合法模型");
let names = m.main_table().unwrap().column_names();
for want in ["f_id", "f_tenant_id", "f_version", "f_flow_state"] {
assert!(names.contains(&want.to_string()), "回写后模型缺 {want}: {names:?}");
}
// 回写的内容与返回值一致
assert_eq!(parsed, out.model);
}
/// 🔴 回写后的模型 ↔ 真实库列**完全一致**。
#[tokio::test]
async fn model_after_write_back_matches_real_db() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_e_main", "sspf_k_ddl_e_sub");
let id = "vd_ddl_e";
insert_visualdev(db, id, "demoDdlE", &model_json(main, sub)).await;
let out = create_and_sync(
db,
id,
&model_of(main, sub),
&form_of(main, sub, false),
false,
)
.await
.expect("建表+回写应成功");
let m = ModelSchema::parse(&out.model).expect("回写模型应可解析");
for t in m.tables.iter() {
let real = real_columns(db, &t.table).await.unwrap();
assert_eq!(
real,
t.column_names(),
"🔴 表 {} 的回写模型与真实库列不一致",
t.table
);
}
}
/// 🔴 逻辑删除 ⇒ 主表与子表**都**有删除列(回写后)。
#[tokio::test]
async fn logical_delete_tables_get_delete_columns() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_f_main", "sspf_k_ddl_f_sub");
let out = create_tables(db, &model_of(main, sub), &form_of(main, sub, true), false)
.await
.expect("建表应成功");
let m = ModelSchema::parse(&out.model).expect("回写模型应可解析");
for t in m.tables.iter() {
let names = t.column_names();
for want in ["f_delete_mark", "f_delete_time", "f_delete_user_id"] {
assert!(
names.contains(&want.to_string()),
"表 {} 缺 {want}: {names:?}",
t.table
);
}
// 🔴 删除标记在真实库里也是 INTEGER
let real = real_columns(db, &t.table).await.unwrap();
assert!(real.contains(&"f_delete_mark".to_string()));
}
}
// ============================================================
// ④ dry-run
// ============================================================
/// 🔴 dry-run:不建表、不回写,但**给出** DDL 与回写后的模型。
#[tokio::test]
async fn dry_run_creates_nothing() {
let _g = LOCK.lock().await;
let db = db().await;
let (main, sub) = ("sspf_k_ddl_g_main", "sspf_k_ddl_g_sub");
let id = "vd_ddl_g";
insert_visualdev(db, id, "demoDdlG", &model_json(main, sub)).await;
let out = create_and_sync(
db,
id,
&model_of(main, sub),
&form_of(main, sub, false),
true,
)
.await
.expect("dry-run 应成功");
assert!(out.dry_run);
assert_eq!(out.tables.len(), 2, "dry-run 也要报出会建哪几张表");
assert!(!out.ddl.is_empty(), "dry-run 要给出 DDL");
// 🔴 没建表
assert!(
!table_exists(db, main).await.unwrap(),
"dry-run 不该建表"
);
// 🔴 没回写
let rows = db
.query_json_params(
"SELECT COALESCE(f_tables_data,'') AS \"tablesData\" FROM base_visual_dev WHERE f_id = $1",
&[&id.to_string()],
)
.await
.expect("读 base_visual_dev 失败");
assert_eq!(
rows[0]["tablesData"].as_str().unwrap_or_default(),
model_json(main, sub),
"🔴 dry-run 不该回写模型"
);
}
// ============================================================
// ⑤ 回写的边界
// ============================================================
/// 🔴 回写到不存在的功能 ⇒ 报 `FORM_NOT_FOUND`。
#[tokio::test]
async fn write_back_to_missing_visualdev_is_rejected() {
let _g = LOCK.lock().await;
let db = db().await;
let err = write_back_model(db, "no-such-id", &json!([]))
.await
.expect_err("回写到不存在的功能必须报错");
assert_eq!(err.code, "FORM_NOT_FOUND");
}
/// 🔴 DDL 预览不碰数据库。
#[tokio::test]
async fn preview_ddl_needs_no_database() {
let (main, sub) = ("sspf_k_ddl_h_main", "sspf_k_ddl_h_sub");
let ddl = preview_ddl(&model_of(main, sub), &form_of(main, sub, false)).expect("预览应成功");
assert_eq!(ddl.len(), 2);
assert!(ddl[0].contains("CREATE TABLE sspf_k_ddl_h_main"));
assert!(ddl[1].contains("CREATE TABLE sspf_k_ddl_h_sub"));
}
+309
View File
@@ -0,0 +1,309 @@
//! 开发期低代码种子的集成测试 —— **真实 pglite 库**。
//!
//! ## 覆盖什么
//!
//! | 测试 | 证明什么 |
//! |---|---|
//! | `preview_needs_no_database` | 演练**连库都不开**(只读 fixture + 算 DDL) |
//! | `seed_creates_real_tables` | 种子真的建出 `test_receivable` / `test_details` |
//! | `seed_writes_visual_dev_and_release` | `base_visual_dev` 与 `base_visual_release` 各有一行 |
//! | `seed_write_back_includes_system_columns` | 回写后的模型含平台系统列(`f_tenant_id` 等) |
//! | `seed_is_idempotent` | 重复跑不报错、不重复行 |
//! | `seeded_feature_supports_record_insert` | 种完的功能够用 `data.record.insert` 写数据 |
//! | `seeded_feature_matches_official_ddl` | 建出来的列与**官方真实 DDL** 逐列一致 |
//!
//! ## 🔴 为什么最后两条最重要
//!
//! 种子的目的不是「库里有行」,而是「**种出来的东西能用**」:
//! - `seeded_feature_supports_record_insert` ⇒ 端到端闭环(种子 → 写工具 → 真落库);
//! - `seeded_feature_matches_official_ddl` ⇒ 列名/类型/顺序与基线平台**一致**
//! (不一致 ⇒ 迁移期跨库读写直接炸)。
use serde_json::Value;
use ssw_platform::lowcode_crud::{build_context, insert_record, now_iso, DEFAULT_TENANT_ID};
use ssw_platform::lowcode_ddl::real_columns;
use ssw_platform::lowcode_seed::{
fixture_path, preview_lowcode_demo, seed_lowcode_demo, DEMO_EN_CODE, DEMO_ID,
};
use ssw_platform::platform::db::Db;
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 临时库失败");
db.ensure_schema().await.expect("ensure_schema 失败");
db
})
.await
}
/// 项目根(测试的 cwd = crate 目录 ⇒ 上溯两级到仓库根)。
fn project_dir() -> std::path::PathBuf {
std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.parent()
.and_then(|p| p.parent())
.expect("应能定位到项目根")
.to_path_buf()
}
/// 官方 fixture 的真实路径(供断言用)。
fn fixture(name: &str) -> std::path::PathBuf {
fixture_path(&project_dir(), name)
}
/// 🔴 演练:**连库都不开**。
#[tokio::test]
async fn preview_needs_no_database() {
// 🔴 刻意**不**取共享库 ⇒ 如果演练偷偷开了库,这里会撞 pglite 的
// 「一个进程只能开一个实例」限制(后面那些测试会开库)⇒ 立刻暴露。
let outcome = preview_lowcode_demo(&project_dir()).expect("演练应成功");
assert!(outcome.dry_run, "演练必须标 dry_run");
assert_eq!(
outcome.tables,
vec!["test_receivable".to_string(), "test_details".to_string()],
"演练要报出要建的两张表"
);
assert!(!outcome.ddl.is_empty(), "演练要给出 DDL");
assert!(outcome.ddl[0].contains("CREATE TABLE test_receivable"));
}
/// 🔴 种子真的建出物理表 + 两行功能定义。
#[tokio::test]
async fn seed_creates_real_tables() {
let _g = LOCK.lock().await;
let db = db().await;
let outcome = seed_lowcode_demo(db, &project_dir())
.await
.expect("种子应成功");
assert!(!outcome.dry_run);
assert_eq!(outcome.form_id, DEMO_ID);
assert_eq!(outcome.en_code, DEMO_EN_CODE);
// ---- 两张表真的在库里 ----
for table in ["test_receivable", "test_details"] {
let cols = real_columns(db, table)
.await
.unwrap_or_else(|e| panic!("表 {table} 应该建出来了: {} {}", e.code, e.message));
assert!(!cols.is_empty(), "表 {table} 应该是有列的");
}
// ---- 功能定义两行都在 ----
for table in ["base_visual_dev", "base_visual_release"] {
let rows = db
.query_json_params(
&format!("SELECT f_id AS \"id\" FROM {table} WHERE f_id = $1 LIMIT 1"),
&[&DEMO_ID.to_string()],
)
.await
.expect("查功能定义");
assert_eq!(rows.len(), 1, "{table} 里应有且只有一行示例功能");
}
}
/// 🔴 回写后的模型含**平台系统列**(`f_tenant_id` / `f_version` …)。
///
/// 这是「建表后回写」机制的价值所在:不回写 ⇒ CRUD 层找不到 `f_delete_mark`
/// ⇒ 逻辑删除直接报 `LOGICAL_DELETE_UNSUPPORTED`。
#[tokio::test]
async fn seed_write_back_includes_system_columns() {
let _g = LOCK.lock().await;
let db = db().await;
let outcome = seed_lowcode_demo(db, &project_dir())
.await
.expect("种子应成功");
let main = outcome.model[0].clone();
let fields = main["fields"].as_array().expect("fields 应是数组");
let names: Vec<&str> = fields
.iter()
.filter_map(|f| f["field"].as_str())
.collect();
for want in [
"f_tenant_id",
"f_version",
"f_flow_id",
"f_flow_task_id",
"f_flow_state",
] {
assert!(
names.contains(&want),
"回写后的模型应含系统列 {want},实际:{names:?}"
);
}
// ---- 库里那一行的 f_tables_data 也要是回写后的 ----
let rows = db
.query_json_params(
"SELECT f_tables_data AS \"tables\" FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
&[&DEMO_ID.to_string()],
)
.await
.expect("读回写的模型");
let text = rows[0]["tables"].as_str().unwrap_or("");
let stored: Value = serde_json::from_str(text).expect("回写的模型应是合法 JSON");
assert_eq!(
stored, outcome.model,
"库里存的模型必须与回写产出逐字一致"
);
}
/// 🔴 **幂等**:重复跑不报错、不重复行。
#[tokio::test]
async fn seed_is_idempotent() {
let _g = LOCK.lock().await;
let db = db().await;
// 第一跑(可能已被前面的测试种过 ⇒ 也应是幂等的)。
seed_lowcode_demo(db, &project_dir()).await.expect("第一次种子");
// 第二跑 ⇒ 表已存在 ⇒ 跳过建表,但**仍回写模型**。
let second = seed_lowcode_demo(db, &project_dir())
.await
.expect("第二次种子也必须成功(幂等)");
assert!(
second.tables.is_empty(),
"第二次不该再建表(已存在)"
);
assert_eq!(
second.skipped,
vec!["test_receivable".to_string(), "test_details".to_string()],
"第二次应把两张表记为「已存在」"
);
// 功能定义仍只有一行。
let rows = db
.query_json_params(
"SELECT f_id AS \"id\" FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
&[&DEMO_ID.to_string()],
)
.await
.expect("查功能定义");
assert_eq!(rows.len(), 1, "重复跑不许留下重复行");
}
/// 🔴 **种完的功能够用** —— 端到端闭环。
#[tokio::test]
async fn seeded_feature_supports_record_insert() {
let _g = LOCK.lock().await;
let db = db().await;
seed_lowcode_demo(db, &project_dir()).await.expect("种子");
// ---- 从库里读回功能定义(模拟 MCP 的 `load_visualdev`)----
let rows = db
.query_json_params(
"SELECT f_form_data AS \"formData\", f_tables_data AS \"tablesData\" \
FROM base_visual_dev WHERE f_id = $1 LIMIT 1",
&[&DEMO_ID.to_string()],
)
.await
.expect("读功能定义");
assert_eq!(rows.len(), 1);
let form = sspf_lowcode::FormSchema::from_str(rows[0]["formData"].as_str().unwrap_or(""))
.expect("表单应可解析");
let model = sspf_lowcode::ModelSchema::from_str(rows[0]["tablesData"].as_str().unwrap_or(""))
.expect("模型应可解析");
// ---- 走真正的写入路径(与 MCP `data.record.insert` 同款)----
let payload = serde_json::json!({ "F_Room": "A-101", "F_Company_name": "某某公司" });
let now = now_iso();
let mut ctx = build_context(None, Some(DEFAULT_TENANT_ID), Some(&now));
let outcome = insert_record(db, &form, &model, &payload, &mut ctx, false)
.await
.expect("种完的功应该能写数据");
assert!(!outcome.id.is_empty(), "应返回记录 id");
// ---- 真落库了 ----
let rows = db
.query_json_params(
"SELECT f_room AS \"room\", f_tenant_id AS \"tenant\" \
FROM test_receivable WHERE f_id = $1 LIMIT 1",
&[&outcome.id],
)
.await
.expect("查刚写的记录");
assert_eq!(rows.len(), 1, "记录应真的在库里");
assert_eq!(rows[0]["room"].as_str(), Some("A-101"));
// 🔴 单租户口径:租户列**必须**被写(Java `addTenantId()` 无条件执行),
// 且值恒为 "0"(`GlobalConst.DEFAULT_TENANT_VALUE`)。
assert_eq!(
rows[0]["tenant"].as_str(),
Some("0"),
"单租户下 f_tenant_id 必须写 \"0\""
);
}
/// 🔴 建出来的列与**官方真实 DDL** 逐列一致。
///
/// 官方(`jnpf_dbnull_init.sql` 的 `CREATE TABLE test_receivable`)的列序:
/// ```text
/// f_id, f_building, f_room, f_company_name, f_userid, f_phone, f_ost,
/// f_sort_code, f_enabledmark, f_creatortime, f_creatoruserid,
/// f_lastmodifytime, f_lastmodifyuserid, f_tenant_id, f_version,
/// f_flowtaskid, f_flow_id, f_flow_task_id, f_inte_assistant, f_flow_state
/// ```
#[tokio::test]
async fn seeded_feature_matches_official_ddl() {
let _g = LOCK.lock().await;
let db = db().await;
seed_lowcode_demo(db, &project_dir()).await.expect("种子");
let cols = real_columns(db, "test_receivable")
.await
.expect("读列");
let expected = [
"f_id",
"f_building",
"f_room",
"f_company_name",
"f_userid",
"f_phone",
"f_ost",
"f_sort_code",
"f_enabledmark",
"f_creatortime",
"f_creatoruserid",
"f_lastmodifytime",
"f_lastmodifyuserid",
"f_tenant_id",
"f_version",
"f_flowtaskid",
"f_flow_id",
"f_flow_task_id",
"f_inte_assistant",
"f_flow_state",
];
assert_eq!(
cols,
expected.iter().map(|s| s.to_string()).collect::<Vec<_>>(),
"🔴 建出来的列必须与官方真实 DDL 逐列一致(列名 + 顺序)"
);
}
/// 🔴 fixture 必须在(种子依赖它 ⇒ 路径错了要立刻报,不是静默跳过)。
#[test]
fn official_fixtures_exist() {
for name in [
"crates/sspf-lowcode/tests/fixtures/sample_form.json",
"crates/sspf-lowcode/tests/fixtures/sample_model.json",
] {
let p = fixture(name);
assert!(p.is_file(), "官方 fixture 必须存在:{}", p.display());
}
}