Files
ssw-platform/src/backend/tests/batch6_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

635 lines
24 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.
//! 批次 6(数据连接 `/api/system/DataSource` + 基准数据类型 `/api/system/BasicDataType` +
//! 常用表字段 `/api/system/CommonFields` + 数据建模只读面 `/api/system/DataModel/**`)集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端页面的一处硬要求):
//! ① `DataSource/Selector` 的**第一组第一项必须是合成「默认数据库」(`id="0"`)** ——
//! `dataCenter/dataModel/index.vue:158-166` 拿 `list[0].children[0]` 当默认连接,
//! 少了它 `dbType` 是 `undefined` ⇒ 建表表单判不出库类型。
//! ② `DataSource` 列表里 `creatorUser` 是 **`真实姓名/账号`**(官方 `UserService` 同款),
//! `port` 是**字符串**、`creatorTime` 是**毫秒数**(官方 VO 的 `String` / `Long`)。
//! ③ 详情**绝不回传明文密码**(`password` 恒空串);`update` 传空串 = **不改密码**。
//! ④ `Actions/Test` 恒业务失败(本仓没有外部驱动层)—— **不假装成功**。
//! ⑤ 基准数据类型 7 行、常用字段 10 行是**平台字典**,`dataTypeName` 由两张表联查拼出。
//! ⑥ 数据建模的字段列表要给出 `primaryKey` / `allowNull` / `identity` 三个 **1/0** 标记,
//! 且 `dataType` 归一成官方那 7 个编码(DB 里是 `character varying` / `integer`)。
//! ⑦ `Table/{t}` 的 `hasTableData` 决定前端**锁不锁已有字段**
//! (`Form.vue:113-115`)⇒ 有数据必须 `true`,判错会让用户在**有数据**的表上删列。
//!
//! 🔴 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
}
/// 面 B 请求(带 `Vue-Version: 3`;`token` 为空串 ⇒ 未登录)。
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(10),
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(10),
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-batch6-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 取库里某列(用于验证「空密码不覆盖旧密码」这类**看不见**的行为)。
async fn scalar(db: &Db, sql: &str) -> String {
let rows = db.query_json_params(sql, &[]).await.expect("查询失败");
rows.first()
.and_then(|r| r.get("v"))
.and_then(Value::as_str)
.unwrap_or_default()
.to_string()
}
// ---------------------------------------------------------------- 数据连接
/// 数据连接 CRUD + 下拉树的「默认数据库」契约。
#[tokio::test]
async fn data_source_crud_and_selector_default_group() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 下拉树第一组第一项 = 合成「默认数据库」,id 必须是 "0"(前端 linkId 默认值)。
let (_, sel) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
assert_eq!(sel["code"], 200, "下拉树失败: {sel}");
let groups = sel["data"]["list"].as_array().expect("必须是 ListVO");
let first_child = &groups[0]["children"][0];
assert_eq!(first_child["id"], "0", "默认库 id 必须是 0: {sel}");
assert_eq!(first_child["fullName"], "默认数据库", "{sel}");
assert_eq!(first_child["dbType"], "PostgreSQL", "默认库类型: {sel}");
// ② 新建(`enabledMark` 落库时被丢弃 ⇒ 表里没有这列,但不该报错)。
let (_, created) = call(
port,
"POST",
"/api/system/DataSource",
&token,
Some(
&json!({
"fullName": "测试库", "dbType": "MySQL", "host": "192.168.1.9",
"port": "3306", "userName": "root", "password": "p@ss",
"serviceName": "demo", "sortCode": 1, "enabledMark": true
})
.to_string(),
),
)
.await;
assert_eq!(created["code"], 200, "新建失败: {created}");
// ③ 同名再建 ⇒ `400 名称已存在`。
let (_, dup) = call(
port,
"POST",
"/api/system/DataSource",
&token,
Some(&json!({"fullName": "测试库", "dbType": "MySQL"}).to_string()),
)
.await;
assert_eq!(dup["code"], 400, "同名必须拒: {dup}");
assert_eq!(dup["msg"], "名称已存在", "{dup}");
// ④ 列表:PageListVO + `creatorUser` 换成「姓名/账号」+ `port` 是字符串。
let (_, listed) = call(port, "GET", "/api/system/DataSource", &token, None).await;
assert_eq!(listed["code"], 200, "{listed}");
assert_eq!(listed["data"]["pagination"]["total"], 1, "{listed}");
let row = &listed["data"]["list"][0];
assert_eq!(row["fullName"], "测试库", "{row}");
assert_eq!(row["port"], "3306", "port 必须是字符串: {row}");
assert_eq!(row["creatorUser"], "管理员/admin", "{row}");
assert_eq!(row["enabledMark"], 1, "表里没有这列 ⇒ 恒 1: {row}");
assert!(
row["creatorTime"].as_i64().unwrap_or(0) > 1_600_000_000_000,
"creatorTime 必须是毫秒数: {row}"
);
let id = row["id"].as_str().expect("必须有 id").to_string();
// ⑤ 详情:**绝不回传明文密码**。
let (_, info) = call(
port,
"GET",
&format!("/api/system/DataSource/{id}"),
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "{info}");
assert_eq!(info["data"]["password"], "", "不能回传明文密码: {info}");
assert_eq!(info["data"]["userName"], "root", "{info}");
// ⑥ 修改:`password: ""` = **不改密码**(前端编辑时密码框本来就是空的)。
let (_, updated) = call(
port,
"PUT",
&format!("/api/system/DataSource/{id}"),
&token,
Some(&json!({"fullName": "测试库2", "port": "3307", "password": ""}).to_string()),
)
.await;
assert_eq!(updated["code"], 200, "修改失败: {updated}");
let stored = scalar(
db().await,
&format!("SELECT f_password AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(stored, "p@ss", "空密码不能把旧密码冲掉");
let port_value = scalar(
db().await,
&format!("SELECT f_port::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(port_value, "3307", "端口要真的改了");
// ⑦ 下拉树要能看到这一个真实连接(第二组,组名 = dbType)。
let (_, sel2) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
let groups = sel2["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(groups.len(), 2, "默认库 + MySQL 一组: {sel2}");
assert_eq!(groups[1]["fullName"], "MySQL", "{sel2}");
assert_eq!(groups[1]["num"], 1, "{sel2}");
// ⑧ 分组视图按 host 分组。
let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await;
assert_eq!(grouped["code"], 200, "{grouped}");
assert_eq!(grouped["data"][0]["host"], "192.168.1.9", "{grouped}");
assert_eq!(grouped["data"][0]["options"][0]["fullName"], "测试库2", "{grouped}");
// ⑨ 测试连接**恒失败**(本仓没有外部驱动层,刻意不假装成功)。
let (_, tested) = call(
port,
"POST",
"/api/system/DataSource/Actions/Test",
&token,
Some(&json!({"dbType": "MySQL", "host": "192.168.1.9"}).to_string()),
)
.await;
assert_eq!(tested["code"], 400, "测试连接必须明确失败: {tested}");
// ⑩ 删除是**软删** ⇒ 列表/分组/下拉三处同时看不到(但库里那行还在)。
let (_, deleted) = call(
port,
"DELETE",
&format!("/api/system/DataSource/{id}"),
&token,
None,
)
.await;
assert_eq!(deleted["code"], 200, "{deleted}");
let (_, after) = call(port, "GET", "/api/system/DataSource", &token, None).await;
assert_eq!(after["data"]["pagination"]["total"], 0, "{after}");
let (_, grouped) = call(port, "GET", "/api/system/DataSource/getGroup", &token, None).await;
assert!(
grouped["data"].as_array().map(Vec::is_empty).unwrap_or(false),
"软删后分组必须空: {grouped}"
);
let (_, sel3) = call(port, "GET", "/api/system/DataSource/Selector", &token, None).await;
assert_eq!(
sel3["data"]["list"].as_array().map(Vec::len),
Some(1),
"软删后只剩默认库: {sel3}"
);
let mark = scalar(
db().await,
&format!("SELECT f_delete_mark::text AS \"v\" FROM base_db_link WHERE f_id = '{id}'"),
)
.await;
assert_eq!(mark, "1", "必须是软删(f_delete_mark=1)");
}
// ---------------------------------------------------------------- 两张平台字典
/// 基准数据类型 7 行 + 常用字段 10 行(官方初始库逐字),`dataTypeName` 联查得出。
#[tokio::test]
async fn basic_data_type_and_common_fields_are_seeded() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 基准数据类型:7 行,`enCode` 是数据建模表单里的 value。
let (_, types) = call(port, "GET", "/api/system/BasicDataType", &token, None).await;
assert_eq!(types["code"], 200, "{types}");
let list = types["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(list.len(), 7, "官方初始库 7 行: {types}");
let codes: Vec<&str> = list
.iter()
.map(|r| r["enCode"].as_str().unwrap_or_default())
.collect();
for code in ["int", "float", "decimal", "datetime", "varchar", "text", "bigint"] {
assert!(codes.contains(&code), "缺少 {code}: {types}");
}
assert_eq!(list[0]["type"], 1, "系统行 f_type=1: {}", list[0]);
// ② 常用字段:10 行,`dataTypeName` 必须由 `base_data_type` 拼出来(不是空)。
let (_, fields) = call(port, "GET", "/api/system/CommonFields", &token, None).await;
assert_eq!(fields["code"], 200, "{fields}");
let list = fields["data"]["list"].as_array().expect("必须是 ListVO");
assert_eq!(list.len(), 10, "官方初始库 10 行: {fields}");
let primary = list
.iter()
.find(|r| r["field"] == "f_id")
.expect("必须有主键字段");
assert_eq!(primary["allowNull"], 0, "主键不允许空: {primary}");
assert_eq!(primary["dataTypeName"], "字符串", "varchar 的中文名: {primary}");
assert_eq!(primary["category"], "2", "官方种子全是常用字段: {primary}");
// `f_allow_delete` 官方种子是 NULL ⇒ 读成 1(允许删),不是 0。
assert_eq!(primary["allowDelete"], 1, "{primary}");
// ③ `category` 过滤生效(1 = 缺省字段,本仓没灌 ⇒ 空)。
let (_, empty) = call(
port,
"GET",
"/api/system/CommonFields?category=1",
&token,
None,
)
.await;
assert_eq!(empty["code"], 200, "{empty}");
assert!(
empty["data"]["list"].as_array().map(Vec::is_empty).unwrap_or(false),
"category=1 应为空: {empty}"
);
}
// ---------------------------------------------------------------- 数据建模只读面
/// 表清单 / 表信息 / 字段 / 下拉 四个读端点的形状与语义。
#[tokio::test]
async fn data_model_tables_info_and_fields() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 表清单:`DbTableListVO`(list + pagination),分页真的生效。
let (_, tables) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=1&pageSize=100",
&token,
None,
)
.await;
assert_eq!(tables["code"], 200, "{tables}");
let total = tables["data"]["pagination"]["total"]
.as_i64()
.expect("必须有 total");
// schema.sql 现在是 52 张表(批次 9 新增 6 张:数据接口 + 接口认证 + 打印模板/版本;
// 批次 10 新增 6 张:签章 + 签章授权人 + 按钮/列表/表单权限 + 高级查询方案;
// 批次 11 新增 3 张:base_module_authorize / base_module_scheme / base_module_link);
// 真有变化时这条会红,提醒同步(与 DDL 计数测试同口径)。
assert_eq!(total, 52, "表清单必须来自 information_schema: {tables}");
let list = tables["data"]["list"].as_array().expect("必须有 list");
assert!(
list.iter().any(|r| r["table"] == "base_user"),
"表清单里必须有 base_user: {tables}"
);
// `tableName` 取 PG 注释(本仓 schema.sql 没写 COMMENT ON ⇒ 空串,不是 null)。
assert_eq!(list[0]["tableName"], "", "注释为空时给空串: {}", list[0]);
// ② 分页:pageSize=5 只回 5 行,第 2 页与第 1 页不重叠。
let (_, page1) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=1&pageSize=5",
&token,
None,
)
.await;
let (_, page2) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?currentPage=2&pageSize=5",
&token,
None,
)
.await;
let p1: Vec<&str> = page1["data"]["list"]
.as_array()
.expect("list")
.iter()
.map(|r| r["table"].as_str().unwrap_or_default())
.collect();
let p2: Vec<&str> = page2["data"]["list"]
.as_array()
.expect("list")
.iter()
.map(|r| r["table"].as_str().unwrap_or_default())
.collect();
assert_eq!(p1.len(), 5, "pageSize 必须生效: {page1}");
assert_eq!(p2.len(), 5, "{page2}");
assert!(
p1.iter().all(|t| !p2.contains(t)),
"两页不许重叠: {p1:?} vs {p2:?}"
);
// ③ keyword 过滤(表名 ILIKE)。
let (_, filtered) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?keyword=bill_rule",
&token,
None,
)
.await;
let hits = filtered["data"]["list"].as_array().expect("list");
assert_eq!(hits.len(), 1, "keyword 必须进 SQL: {filtered}");
assert_eq!(hits[0]["table"], "base_bill_rule", "{filtered}");
// ④ TableAll 是**裸 ListVO**(没有 pagination)。
let (_, all) = call(port, "GET", "/api/system/DataModel/0/TableAll", &token, None).await;
assert_eq!(all["code"], 200, "{all}");
assert!(
all["data"]["pagination"].is_null(),
"TableAll 不许带 pagination: {all}"
);
assert!(
all["data"]["list"]
.as_array()
.map(|l| l.len() >= 35)
.unwrap_or(false),
"{all}"
);
// ⑤ 字段列表:三个 1/0 标记 + `dataType` 归一 + `dataTypeName` 联查。
let (_, fields) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/base_user/Fields?type=0",
&token,
None,
)
.await;
assert_eq!(fields["code"], 200, "{fields}");
let list = fields["data"]["list"].as_array().expect("ListVO");
assert!(!list.is_empty(), "{fields}");
let id_col = list
.iter()
.find(|r| r["field"] == "f_id")
.expect("base_user.f_id 必须在");
assert_eq!(id_col["primaryKey"], 1, "主键标记: {id_col}");
assert_eq!(id_col["allowNull"], 0, "主键非空: {id_col}");
assert_eq!(id_col["identity"], 0, "不是自增: {id_col}");
// DB 里是 `character varying(50)` ⇒ 归一成 `varchar` / `50`。
assert_eq!(id_col["dataType"], "varchar", "{id_col}");
assert_eq!(id_col["dataLength"], "50", "{id_col}");
assert_eq!(id_col["dataTypeName"], "字符串", "{id_col}");
assert_eq!(id_col["columnName"], "f_id", "官方 VO 的 columnName: {id_col}");
// ⑥ `Fields/Selector` 走同一份数据。
let (_, selector) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/base_user/Fields/Selector",
&token,
None,
)
.await;
assert_eq!(selector["code"], 200, "{selector}");
assert_eq!(
selector["data"]["list"].as_array().map(Vec::len),
Some(list.len()),
"Selector 与 Fields 必须同源: {selector}"
);
// ⑦ 表信息:`tableInfo` + `tableFieldList` + `hasTableData`(有数据 ⇒ true)。
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_user",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "{info}");
assert_eq!(info["data"]["tableInfo"]["table"], "base_user", "{info}");
assert_eq!(info["data"]["hasTableData"], true, "有数据必须 true: {info}");
assert!(
info["data"]["tableFieldList"]
.as_array()
.map(|l| !l.is_empty())
.unwrap_or(false),
"{info}"
);
// ⑧ 表名不存在 / 不合法 ⇒ 业务失败(不是空列表、更不是 500)。
let (_, missing) = call(
port,
"GET",
"/api/system/DataModel/0/Table/no_such_table",
&token,
None,
)
.await;
assert_eq!(missing["code"], 400, "{missing}");
let (_, bad) = call(
port,
"GET",
"/api/system/DataModel/0/Tables/no_such_table/Fields",
&token,
None,
)
.await;
assert_eq!(bad["code"], 400, "{bad}");
let (_, illegal) = call(
port,
"GET",
"/api/system/DataModel/0/Table/a%22b%3Bdrop",
&token,
None,
)
.await;
assert_eq!(illegal["code"], 400, "标识符白名单必须拦住: {illegal}");
assert_eq!(illegal["msg"], "表名不合法", "{illegal}");
}
/// 表数据预览:分页 + 单字段模糊(`Preview.vue` 的搜索表单就这两个参数)。
#[tokio::test]
async fn data_model_preview_paginates_and_filters() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 拿一张**行数稳定**的表:`base_data_type` 恰好是种子灌的 7 行。
let (_, p1) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=1&pageSize=3",
&token,
None,
)
.await;
assert_eq!(p1["code"], 200, "{p1}");
assert_eq!(p1["data"]["pagination"]["total"], 7, "{p1}");
assert_eq!(p1["data"]["list"].as_array().map(Vec::len), Some(3), "{p1}");
let (_, p3) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?currentPage=3&pageSize=3",
&token,
None,
)
.await;
assert_eq!(
p3["data"]["list"].as_array().map(Vec::len),
Some(1),
"第 3 页只剩 1 行: {p3}"
);
// 单字段模糊:`f_en_code ILIKE '%varchar%'` ⇒ 只剩「字符串」那一行。
let (_, filtered) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?field=f_en_code&keyword=varchar",
&token,
None,
)
.await;
assert_eq!(filtered["code"], 200, "{filtered}");
assert_eq!(filtered["data"]["pagination"]["total"], 1, "{filtered}");
let row = &filtered["data"]["list"][0];
assert_eq!(row["f_en_code"], "varchar", "行键必须是真实列名: {row}");
assert_eq!(row["f_full_name"], "字符串", "{row}");
// 只给 keyword、不给 field ⇒ **不加条件**(官方同款:空 field 不过滤)。
let (_, no_field) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_data_type/Preview?keyword=varchar",
&token,
None,
)
.await;
assert_eq!(no_field["data"]["pagination"]["total"], 7, "{no_field}");
}
/// 未登录 ⇒ 面 B 的 `602`(不是 600,也不是 401)。
#[tokio::test]
async fn data_model_and_data_source_require_login() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
for path in [
"/api/system/DataModel/0/Tables",
"/api/system/DataModel/0/Table/base_user",
"/api/system/DataSource",
"/api/system/DataSource/Selector",
"/api/system/BasicDataType",
"/api/system/CommonFields",
] {
let (status, body) = call(port, "GET", path, "", None).await;
assert!(
status.contains("200"),
"业务失败恒 HTTP 200({path}): {status}"
);
assert_eq!(body["code"], 602, "{path} 未登录必须是 602: {body}");
}
}