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