Files
ssw-platform/src/backend/tests/batch10_it.rs
T
admin 4b14ecd96f feat(face-b): 数据权限三件套落地(面 B 批次 11,+15 端点)
ModuleDataAuthorize(6) + ModuleDataAuthorizeScheme(5) + ModuleDataAuthorizeLink(4)
= 15 端点 / 3 张新表(base_module_authorize / base_module_scheme / base_module_link)。

- enCode 前缀化:type=3 菜单 + bindTable 非空 ⇒ 落库存 bindTable.enCode,读回剥前缀;
  create 用 fieldRule!=0、update 用 fieldRule==1(对齐官方两处判据)。
- delete 前遍历方案 conditionJson 比对 field(带前缀、equalsIgnoreCase)⇒ SYS020 拦截。
- 方案双判重(EXIST001/EXIST002)、列表仅需登录、allData==1 ⇒ SYS021 拦截。
- 诚实降级:FieldList 与表字段端点依赖低代码表单/数据库内省 ⇒ 返回空数组/空 PageListVO。

顺手修 4 个真 bug:
- b10_insert 把 None 当 now() 绑定 ⇒ 整型列类型错(f_all_data / f_type / f_field_rule ×2)。
- 写路径补齐「只 SET body 里出现的键」:enCode / linkId / linkTables 缺省时保持原值。
- getVisualTables / getInfo 查 f_type(int4)缺 ::text::integer CAST ⇒ 协议类型错。
- batch10 测试跨用例污染:列表权限批量断言写死 0 ⇒ 改为基线相对。
2026-11-01 19:06:44 +08:00

823 lines
28 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.
//! 批次 10(**电子签章 / 按钮权限 / 列表权限 / 表单权限 / 高级查询方案**)集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端组件的一处硬要求):
//! ① 电子签章:官方**没有** `@SaCheckPermission` ⇒ 只需登录(不判点权限)。
//! ② 签章列表 `userIds` = 「真实名/账号」,多个用 **「;」** 连接(官方 `StringJoiner`);
//! 但**详情**的 `userIds` 是**数组**(官方 `SignatureInfoVO` 是 `List<String>`)。
//! ③ 签章**名称 / 编码是两次独立判重** ⇒ 撞名报「名称不能重复」、撞码报「编码不能重复」。
//! ④ 签章更新时 `userIds` 变化 ⇒ **先删后插**全量重建授权人。
//! ⑤ 按钮/列表/表单权限:官方 `@SaCheckPermission(mode=OR)` 两码 ⇒ 契约写 `A|B`。
//! ⑥ 按钮 `selectActions`:**任一条撞码 ⇒ 整体失败且不落库**(官方逐条判重后 return)。
//! ⑦ 列表/表单权限 `enCode` **前缀化**:fieldRule=1 ⇒ `jnpf_<bindTable>_jnpf_<code>`;
//! fieldRule=2 ⇒ `<childTableKey>-<code>`;读回时**剥掉**前缀。
//! ⑧ 批量创建:**批内撞码**也判失败(官方 `name.contains(enCode)`)。
//! ⑨ 高级查询方案:**只看自己的**(官方 `getList/getInfo/delete` 都带 `userId` 过滤)。
//! ⑩ 高级查询方案列表是 `ListVO`(不是 `PageListVO`)—— 官方 `ActionResult<ListVO<…>>`。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志** ⇒ 全文件共用一个临时库 + 一把互斥锁。
use std::path::PathBuf;
use std::sync::Arc;
use serde_json::{json, Value};
use ssw_platform::bootstrap::ensure_base;
use ssw_platform::platform::config::Config;
use ssw_platform::platform::db::Db;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::SessionStore;
use ssw_platform::platform::state::AppState;
use ssw_platform::routes::build_app;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
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 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
async fn serve(state: AppState) -> u16 {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("绑定失败");
let port = listener.local_addr().expect("取本地地址失败").port();
let server = tokio::spawn(async move {
let _ = axum::serve(listener, build_app(state)).await;
});
tokio::task::yield_now().await;
std::mem::forget(server);
port
}
async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> (String, Value) {
let mut stream = TcpStream::connect(("127.0.0.1", port)).await.expect("连接失败");
let payload = body.unwrap_or("");
let req = format!(
"{method} {path} HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Authorization: {token}\r\n\
Content-Type: application/json\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(std::time::Duration::from_secs(15), stream.read_to_end(&mut buf))
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let status = head.lines().next().unwrap_or_default().to_string();
let json: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null);
(status, json)
}
async fn login(port: u16) -> String {
let enc = ssw_platform::platform::cipher::encrypt_password("123456");
let payload = format!("account=admin&password={enc}");
let mut stream = TcpStream::connect(("127.0.0.1", port)).await.expect("连接失败");
let req = format!(
"POST /api/oauth/Login HTTP/1.1\r\n\
Host: 127.0.0.1\r\n\
Vue-Version: 3\r\n\
App-Code: mainSystem\r\n\
Content-Type: application/x-www-form-urlencoded\r\n\
Content-Length: {}\r\n\
Connection: close\r\n\r\n{payload}",
payload.len()
);
stream.write_all(req.as_bytes()).await.expect("写请求失败");
let mut buf = Vec::new();
tokio::time::timeout(std::time::Duration::from_secs(15), stream.read_to_end(&mut buf))
.await
.expect("读响应超时")
.expect("读响应失败");
let text = String::from_utf8_lossy(&buf).to_string();
let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔");
let json: Value = serde_json::from_str(body.trim()).expect("登录响应必须是 JSON");
json["data"]["token"].as_str().expect("登录必须返回 token").to_string()
}
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-batch10-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 取一个真实存在的菜单 id(官方这些端点都挂在某个菜单下)。
///
/// 🔴 **直接查库**而不是走端点 —— 端点返回的是菜单**树**(`children` 嵌套),
/// 从里面挑「功能菜单(type=2)」要递归;查库直白且不受端点形状影响。
async fn any_menu_id() -> String {
let rows = ssw_platform::platform::db::Db::query_json_params(
db().await,
"SELECT f_id AS \"id\" FROM base_module \
WHERE COALESCE(f_delete_mark, 0) = 0 AND f_type = 2 ORDER BY f_sort_code ASC LIMIT 1",
&[],
)
.await
.expect("查菜单失败");
assert!(!rows.is_empty(), "库里必须有 type=2 的功能菜单");
rows[0]["id"].as_str().expect("菜单必须有 id").to_string()
}
/// 新建签章,返回 id。
async fn create_signature(port: u16, token: &str, name: &str, code: &str, user_ids: Vec<&str>) -> String {
let body = json!({
"fullName": name,
"enCode": code,
"icon": "icon-1",
"userIds": user_ids,
});
let (_, resp) = call(
port,
"POST",
"/api/system/Signature",
token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建签章应成功:{resp}");
resp["data"]["id"].as_str().expect("必须返回 id").to_string()
}
/// ① + ② + ③:签章的双判重、列表 `userIds` 拼接、详情 `userIds` 是数组。
#[tokio::test]
async fn signature_dedup_and_user_ids_shape() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let id = create_signature(port, &token, "合同签章", "sig_contract", vec!["u_admin"]).await;
// ③ 撞**名称** ⇒ 「名称不能重复」(不是编码的文案)。
let dup_name = json!({ "fullName": "合同签章", "enCode": "sig_other" });
let (_, resp) = call(
port,
"POST",
"/api/system/Signature",
&token,
Some(&dup_name.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "撞名必须失败:{resp}");
assert_eq!(resp["msg"], "名称不能重复", "撞名文案:{resp}");
// ③ 撞**编码** ⇒ 「编码不能重复」。
let dup_code = json!({ "fullName": "别的签章", "enCode": "sig_contract" });
let (_, resp) = call(
port,
"POST",
"/api/system/Signature",
&token,
Some(&dup_code.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "撞码必须失败:{resp}");
assert_eq!(resp["msg"], "编码不能重复", "撞码文案:{resp}");
// ② 详情:`userIds` 是**数组**。
let (_, resp) = call(port, "GET", &format!("/api/system/Signature/{id}"), &token, None).await;
assert_eq!(resp["code"], 200, "签章详情应成功:{resp}");
assert!(
resp["data"]["userIds"].is_array(),
"详情的 userIds 必须是数组:{resp}"
);
assert_eq!(resp["data"]["userIds"].as_array().unwrap().len(), 1);
// ② 列表:`userIds` 是**字符串**(官方 StringJoiner 形状)。
let (_, resp) = call(port, "GET", "/api/system/Signature", &token, None).await;
assert_eq!(resp["code"], 200, "签章列表应成功:{resp}");
let list = resp["data"]["list"].as_array().expect("必须是 PageListVO");
let item = list
.iter()
.find(|r| r["id"] == json!(id))
.expect("列表里必须有刚建的签章");
assert!(
item["userIds"].is_string(),
"列表的 userIds 必须是字符串:{item}"
);
// 官方 `真实名/账号`;查不到用户时官方留空 ⇒ 这里只钉「是字符串」。
assert!(item["userIds"].as_str().unwrap().contains('/')
|| item["userIds"].as_str().unwrap().is_empty());
}
/// ④:签章更新时 `userIds` 变化 ⇒ 全量重建授权人。
#[tokio::test]
async fn signature_update_rebuilds_users() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let id = create_signature(port, &token, "重建签章", "sig_rebuild", vec!["u_a", "u_b"]).await;
let (_, resp) = call(port, "GET", &format!("/api/system/Signature/{id}"), &token, None).await;
assert_eq!(
resp["data"]["userIds"].as_array().unwrap().len(),
2,
"初始应有 2 个授权人:{resp}"
);
// 改成 1 个 ⇒ 旧的全删、只留新的。
let body = json!({ "userIds": ["u_c"] });
let (_, resp) = call(
port,
"PUT",
&format!("/api/system/Signature/{id}"),
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "更新签章应成功:{resp}");
let (_, resp) = call(port, "GET", &format!("/api/system/Signature/{id}"), &token, None).await;
let users = resp["data"]["userIds"].as_array().expect("必须是数组");
assert_eq!(users.len(), 1, "授权人必须被全量重建:{resp}");
assert_eq!(users[0], json!("u_c"), "应只剩 u_c:{resp}");
}
/// 签章下拉框 + 按 ids 取 + 软删。
#[tokio::test]
async fn signature_selector_list_by_ids_and_soft_delete() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let id = create_signature(port, &token, "下拉签章", "sig_dropdown", vec![]).await;
// Selector ⇒ ListVO。
let (_, resp) = call(port, "GET", "/api/system/Signature/Selector", &token, None).await;
assert_eq!(resp["code"], 200, "下拉框应成功:{resp}");
assert!(resp["data"]["list"].is_array(), "必须是 ListVO:{resp}");
// ListByIds ⇒ 只回给定的那些。
let body = json!({ "ids": [id] });
let (_, resp) = call(
port,
"POST",
"/api/system/Signature/ListByIds",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "ListByIds 应成功:{resp}");
let list = resp["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(list.len(), 1, "只应返 1 条:{resp}");
assert_eq!(list[0]["id"], json!(id));
// 软删后再取 ⇒ 数据不存在。
let (_, resp) = call(
port,
"DELETE",
&format!("/api/system/Signature/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "删除应成功:{resp}");
let (_, resp) = call(port, "GET", &format!("/api/system/Signature/{id}"), &token, None).await;
assert_eq!(resp["code"], 400, "删后详情应失败:{resp}");
assert_eq!(resp["msg"], "数据不存在", "删后详情文案:{resp}");
}
/// ⑤ + ⑥:按钮权限的 OR 守卫、编码判重、selectActions「任一撞 ⇒ 整体失败」。
#[tokio::test]
async fn module_button_dedup_and_select_actions_atomic() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
// 建两个按钮。
for (name, code) in [("新增", "btn_add"), ("编辑", "btn_edit")] {
let body = json!({ "fullName": name, "enCode": code, "moduleId": menu_id });
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleButton",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建按钮应成功:{resp}");
}
// 同菜单内撞码 ⇒ 「编码不能重复」。
let dup = json!({ "fullName": "另一个新增", "enCode": "btn_add", "moduleId": menu_id });
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleButton",
&token,
Some(&dup.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "撞码必须失败:{resp}");
assert_eq!(resp["msg"], "编码不能重复", "撞码文案:{resp}");
// 列表 ⇒ PageListVO。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleButton/{menu_id}/List"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "按钮列表应成功:{resp}");
assert!(resp["data"]["pagination"].is_object(), "必须是 PageListVO:{resp}");
let list = resp["data"]["list"].as_array().unwrap();
assert!(list.len() >= 2, "应有 2 个按钮:{resp}");
// 下拉框 ⇒ ListVO + 树(parentId=-1 视为根)。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleButton/{menu_id}/Selector"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "按钮下拉应成功:{resp}");
let tree = resp["data"]["list"].as_array().expect("必须是 ListVO");
assert!(!tree.is_empty(), "树不应为空:{resp}");
assert!(
tree.iter().all(|n| n["hasChildren"].is_boolean() && n["children"].is_array()),
"树的每个节点都要有 hasChildren + children:{resp}"
);
// ⑥ selectActions:一条撞码 ⇒ 整体失败且**不落库**。
let before = call(
port,
"GET",
&format!("/api/system/ModuleButton/{menu_id}/List"),
&token,
None,
)
.await
.1["data"]["list"]
.as_array()
.unwrap()
.len();
let body = json!({
"menuId": menu_id,
"ids": [
{ "fullName": "删除", "enCode": "btn_del", "description": "删除" },
{ "fullName": "导入", "enCode": "btn_add", "description": "导入" }
],
});
let (_, resp) = call(
port,
"POST",
&format!("/api/system/ModuleButton/selectActions/{menu_id}"),
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "撞码必须整体失败:{resp}");
let after = call(
port,
"GET",
&format!("/api/system/ModuleButton/{menu_id}/List"),
&token,
None,
)
.await
.1["data"]["list"]
.as_array()
.unwrap()
.len();
assert_eq!(after, before, "失败时一条都不许落库:{before} → {after}");
// 不撞码 ⇒ 全部落库,且 parentId = "-1"、enabledMark = 1。
let body = json!({
"menuId": menu_id,
"ids": [
{ "fullName": "删除", "enCode": "btn_del", "description": "删除" },
{ "fullName": "导出", "enCode": "btn_export", "description": "导出" }
],
});
let (_, resp) = call(
port,
"POST",
&format!("/api/system/ModuleButton/selectActions/{menu_id}"),
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "selectActions 应成功:{resp}");
let after = call(
port,
"GET",
&format!("/api/system/ModuleButton/{menu_id}/List"),
&token,
None,
)
.await
.1["data"]["list"]
.as_array()
.unwrap()
.clone();
assert_eq!(after.len(), before + 2, "应新增 2 个:{before} → {}", after.len());
let added = after
.iter()
.find(|r| r["enCode"] == json!("btn_del"))
.expect("应新增 btn_del");
assert_eq!(added["parentId"], json!("-1"), "parentId 应为 -1");
assert_eq!(added["enabledMark"], json!(1), "enabledMark 应为 1");
}
/// ⑦:列表权限的 `enCode` 前缀化(写入前缀化、读回剥掉)。
#[tokio::test]
async fn module_column_en_code_prefix_and_strip() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
// fieldRule=1 + bindTable ⇒ 落库是 `jnpf_<bindTable>_jnpf_<code>`,读回是裸 code。
let body = json!({
"fullName": "名称字段",
"enCode": "f_name",
"moduleId": menu_id,
"bindTable": "demo_item",
"fieldRule": 1,
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleColumn",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建列表权限应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// 详情 ⇒ 已剥掉前缀。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "详情应成功:{resp}");
assert_eq!(
resp["data"]["enCode"], json!("f_name"),
"详情应剥掉前缀:{resp}"
);
assert_eq!(
resp["data"]["childTableKey"], json!("tableField"),
"childTableKey 默认 tableField:{resp}"
);
// 列表 ⇒ 也剥掉前缀。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{menu_id}/Fields"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "列表应成功:{resp}");
let list = resp["data"]["list"].as_array().unwrap();
let item = list
.iter()
.find(|r| r["id"] == json!(id))
.expect("列表里必须有刚建的");
assert_eq!(item["enCode"], json!("f_name"), "列表应剥掉前缀:{item}");
// 🔴 **库里存的是带前缀的**(官方语义)—— 直接查库核对。
let rows = ssw_platform::platform::db::Db::query_json_params(
db().await,
"SELECT f_en_code AS \"enCode\" FROM base_module_column WHERE f_id = $1::text",
&[&id],
)
.await
.expect("查库失败");
assert_eq!(
rows[0]["enCode"], json!("jnpf_demo_item_jnpf_f_name"),
"库里应存带前缀的编码:{rows:?}"
);
// fieldRule=2 + childTableKey ⇒ `<childTableKey>-<code>`。
let body = json!({
"fullName": "子表字段",
"enCode": "f_child",
"moduleId": menu_id,
"childTableKey": "tableField",
"fieldRule": 2,
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleColumn",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建子表字段应成功:{resp}");
let id2 = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{id2}"),
&token,
None,
)
.await;
assert_eq!(
resp["data"]["enCode"], json!("f_child"),
"fieldRule=2 的详情也应剥掉前缀:{resp}"
);
}
/// ⑧:批量创建 —— **批内撞码**也判失败。
#[tokio::test]
async fn module_column_batch_rejects_duplicate_in_batch() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
// 🔴 **基线要按「改之前有多少行」算,不能写死 0** —— 本文件共用一个 pglite 临时库,
// `any_menu_id()` 对每个测试都返回**同一个**菜单 ⇒ 别的测试已经建过列表权限行。
// 断言的语义是「失败时**不新增**行」,不是「这个菜单下必须为空」。
let before = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{menu_id}/Fields"),
&token,
None,
)
.await
.1["data"]["list"]
.as_array()
.expect("必须是 PageListVO")
.len();
// 批内两条同 code ⇒ 失败,且一条都不落库。
let body = json!({
"moduleId": menu_id,
"bindTable": "demo_item",
"fieldRule": 1,
"columnJson": [
{ "fullName": "甲", "enCode": "f_dup" },
{ "fullName": "乙", "enCode": "f_dup" }
],
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleColumn/Actions/Batch",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "批内撞码必须失败:{resp}");
assert_eq!(resp["msg"], "编码不能重复", "批内撞码文案:{resp}");
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{menu_id}/Fields"),
&token,
None,
)
.await;
let count = resp["data"]["list"].as_array().unwrap().len();
assert_eq!(count, before, "失败时一条都不许落库:{before} → {count}");
// 不撞码 ⇒ 全部落库。
let body = json!({
"moduleId": menu_id,
"bindTable": "demo_item",
"fieldRule": 1,
"columnJson": [
{ "fullName": "甲", "enCode": "f_a" },
{ "fullName": "乙", "enCode": "f_b" }
],
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleColumn/Actions/Batch",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "批量应成功:{resp}");
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleColumn/{menu_id}/Fields"),
&token,
None,
)
.await;
// 🔴 同样是「相对基线 +2」(这个菜单下别的测试可能已建过行)。
assert_eq!(
resp["data"]["list"].as_array().unwrap().len(),
before + 2,
"应落库 2 条:{before} → {}",
resp["data"]["list"].as_array().unwrap().len()
);
}
/// 表单权限:与列表权限同规则(前缀化 / 剥前缀 / 详情默认 childTableKey)。
#[tokio::test]
async fn module_form_prefix_and_defaults() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
let body = json!({
"fullName": "表单字段",
"enCode": "ff_name",
"moduleId": menu_id,
"bindTable": "demo_item",
"fieldRule": 1,
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleForm",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建表单权限应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
let (_, resp) = call(
port,
"GET",
&format!("/api/system/ModuleForm/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "详情应成功:{resp}");
assert_eq!(
resp["data"]["enCode"], json!("ff_name"),
"详情应剥掉前缀:{resp}"
);
assert_eq!(
resp["data"]["childTableKey"], json!("tableField"),
"childTableKey 默认 tableField:{resp}"
);
// 表单权限批量 ⇒ 撞码失败。
let body = json!({
"moduleId": menu_id,
"formJson": [
{ "fullName": "甲", "enCode": "ff_dup" },
{ "fullName": "乙", "enCode": "ff_dup" }
],
});
let (_, resp) = call(
port,
"POST",
"/api/system/ModuleForm/Actions/Batch",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "批内撞码必须失败:{resp}");
}
/// ⑨ + ⑩:高级查询方案 —— 只看自己的;列表是 `ListVO` 不是 `PageListVO`。
#[tokio::test]
async fn advanced_query_is_owner_scoped_and_list_vo() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let menu_id = any_menu_id().await;
let body = json!({
"fullName": "我的方案",
"matchLogic": "and",
"conditionJson": "[{\"field\":\"name\",\"op\":\"like\",\"value\":\"a\"}]",
"moduleId": menu_id,
});
let (_, resp) = call(
port,
"POST",
"/api/system/AdvancedQuery",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 200, "新建方案应成功:{resp}");
let id = resp["data"]["id"].as_str().expect("必须返回 id").to_string();
// ⑩ 列表 ⇒ `ListVO`(**没有** pagination 字段)。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/AdvancedQuery/{menu_id}/List"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "方案列表应成功:{resp}");
assert!(
resp["data"]["list"].is_array(),
"必须是 ListVO 的 list:{resp}"
);
assert!(
resp["data"].get("pagination").is_none(),
"高级查询列表**不是** PageListVO:{resp}"
);
let list = resp["data"]["list"].as_array().unwrap();
assert_eq!(list.len(), 1, "应有 1 条:{resp}");
assert_eq!(list[0]["id"], json!(id));
// ⑨ 详情 ⇒ 自己的能取到。
let (_, resp) = call(
port,
"GET",
&format!("/api/system/AdvancedQuery/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 200, "自己的方案应能取到:{resp}");
assert_eq!(resp["data"]["matchLogic"], json!("and"), "字段应对齐:{resp}");
// ⑨ 别人的方案(直接改库里的 creator)⇒ 看不到。
ssw_platform::platform::db::Db::exec_params(
db().await,
"UPDATE base_advanced_query_scheme SET f_creator_user_id = 'u_other' WHERE f_id = $1::text",
&[&id],
)
.await
.expect("改库失败");
let (_, resp) = call(
port,
"GET",
&format!("/api/system/AdvancedQuery/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 400, "别人的方案应看不到:{resp}");
assert_eq!(resp["msg"], "数据不存在", "别人的方案文案:{resp}");
// ⑨ 别人的方案也删不掉。
let (_, resp) = call(
port,
"DELETE",
&format!("/api/system/AdvancedQuery/{id}"),
&token,
None,
)
.await;
assert_eq!(resp["code"], 400, "别人的方案应删不掉:{resp}");
assert_eq!(resp["msg"], "删除失败,数据不存在", "别人的方案文案:{resp}");
}
/// 必填校验:官方 `@NotBlank` 的四个字段缺一不可。
#[tokio::test]
async fn advanced_query_required_fields() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
for (body, why) in [
(json!({ "enCode": "x" }), "缺 fullName/conditionJson/matchLogic/moduleId"),
(
json!({ "fullName": "甲", "conditionJson": "[]", "matchLogic": "and" }),
"缺 moduleId",
),
] {
let (_, resp) = call(
port,
"POST",
"/api/system/AdvancedQuery",
&token,
Some(&body.to_string()),
)
.await;
assert_eq!(resp["code"], 400, "必填校验必须失败({why}):{resp}");
}
}