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 ⇒ 改为基线相对。
635 lines
24 KiB
Rust
635 lines
24 KiB
Rust
//! 批次 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}");
|
||
}
|
||
}
|