Files
ssw-platform/src/backend/tests/batch7_it.rs
T
admin 6f8dcaa58a feat(face-b): 数据建模写面落地(面 B 批次 7,+8 端点,真 DDL)
- 建表/改表/加字段/删表/清空/复制/导出/导入 八条,均过 db_ident 白名单
- 内置表护栏取 DDL 真源:schema.sql 里 35 张全部只给看(禁改禁删)
- 官方 checkTab 双闸照抄:系统自带表 DB101/DB102、表里有数据 DB201/DB202
- update 是重建表 ⇒ 用 DROP+CREATE 同一批给 exec(隐式事务,无中间态)
- addFields 不要求主键、只 ADD COLUMN IF NOT EXISTS、新列一律可空
- Copy 用 LIKE … INCLUDING ALL(保主键/自增);带数据走显式列清单避开 MEM1
- 修 db_field_rows 的 decimal 长度:18 → 18,4(否则编辑一次表就丢小数位)
- deleteAllTable 有意收窄:只删非内置表(官方全删含系统表 = 拆平台)
- Export/Import 恒 400 + 人话,不返假下载地址
- 回归 tests/batch7_it.rs(8 条);cargo test --workspace 521 passed
2026-11-01 09:03:21 +08:00

805 lines
25 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.
//! 批次 7(数据建模**写面** `/api/system/DataModel/**`:建表 / 改表 / 加字段 / 删表 / 复制)
//! 集成测试。
//!
//! 🔴 **钉住的契约点**(每条都对应官方控制器 / 前端页面的一处硬要求):
//! ① 建表成功后 `Table/{t}` 的 `dataLength` 对 `decimal` 必须是 **`18,4`**(带小数位)——
//! 只给精度(`18`)会让前端编辑一次表就把 `numeric(18,4)` 改成 `numeric(18,0)`,**静默丢精度**。
//! ② 表名撞**内置表**(`schema.sql` 定义过的 35 张)⇒ `400 名称不能重复`;
//! 改/删内置表 ⇒ `400 系统自带表,不允许被编辑|删除`(官方 `DB102`/`DB101`)。
//! ③ 表里**有数据**时改结构 / 删表一律拒(官方 `DB202`/`DB201`)——
//! 放行等于让用户在建模页一键抹掉业务数据。
//! ④ `update` 是**重建表**:改名后旧表必须消失、新表字段是请求里的那一套
//! (官方也是 `creTable`→`dropTable`→`reTableName`)。
//! ⑤ `addFields` **只追加、不删列**,且**不要求主键**(主键早就在表上了)。
//! ⑥ `Copy` 的 `type=1` 要带数据(`INSERT … SELECT *`);`LIKE … INCLUDING ALL`
//! ⇒ 主键 / `NOT NULL` / 自增一起过去。
//! ⑦ `Export` / `Import` 恒 `400` + 人话(本仓没有文件服务)—— **不假装成功**。
//!
//! 🔴 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`)。
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-batch7-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::default()),
}
}
/// 一个字段(形状照抄 `Form.vue:239` 的 `query.tableFieldList` 元素)。
fn field(name: &str, cn: &str, ty: &str, len: Value, pk: bool, identity: bool) -> Value {
json!({
"field": name,
"fieldName": cn,
"dataType": ty,
"dataLength": len,
"allowNull": if pk { 0 } else { 1 },
"primaryKey": if pk { 1 } else { 0 },
"identity": if identity { 1 } else { 0 },
})
}
/// 建表请求体(`table` 传空串 = 新建;改表时传旧名)。
fn create_body(table: &str, comment: &str, fields: Vec<Value>) -> String {
json!({
"tableInfo": { "table": table, "tableName": comment, "newTable": table },
"tableFieldList": fields,
})
.to_string()
}
// ---------------------------------------------------------------- 建表
/// 建表 → 读回形状 → 重名被拒。`dataLength` 对 `decimal` **必须带小数位**。
#[tokio::test]
async fn create_table_round_trips_and_rejects_duplicate() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_order",
"批次7订单",
vec![
field("id", "主键", "varchar", json!(32), true, false),
field("amount", "金额", "decimal", json!("18,4"), false, false),
field("created_at", "创建时间", "datetime", json!(0), false, false),
field("remark", "备注", "text", json!(0), false, false),
],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "建表应成功: {created}");
assert_eq!(created["data"], "新建成功", "官方 `MsgCode.SU001` 同款: {created}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_order",
&token,
None,
)
.await;
assert_eq!(info["code"], 200, "表信息应可读: {info}");
let data = &info["data"];
assert_eq!(data["tableInfo"]["tableName"], "批次7订单", "表注释要落库: {data}");
assert_eq!(data["hasTableData"], false, "新表必须无数据: {data}");
let fields = data["tableFieldList"].as_array().expect("字段必须是数组");
assert_eq!(fields.len(), 4, "{data}");
let amount = fields
.iter()
.find(|f| f["field"] == "amount")
.expect("必须能读回 amount");
// 🔴 只给 `18`(丢了 scale)⇒ 前端编辑一次就把 `numeric(18,4)` 改成 `numeric(18,0)`。
assert_eq!(amount["dataLength"], "18,4", "decimal 必须带小数位: {amount}");
assert_eq!(amount["dataType"], "decimal", "{amount}");
assert_eq!(amount["allowNull"], 1, "{amount}");
let id = fields
.iter()
.find(|f| f["field"] == "id")
.expect("必须能读回 id");
assert_eq!(id["primaryKey"], 1, "主键标记: {id}");
assert_eq!(id["allowNull"], 0, "主键自动 NOT NULL: {id}");
// 再建一次同名 ⇒ 官方 `createTable` 返回 0 ⇒ `EXIST001`「名称不能重复」。
let (_, dup) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(dup["code"], 400, "{dup}");
assert_eq!(dup["msg"], "名称不能重复", "必须是中文人话,不是 PG 的 42P07: {dup}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_order",
&token,
None,
)
.await;
}
/// 建表的三类非法输入:撞内置表 / 无主键 / 类型不支持 / 列名非法 / 自增类型错。
#[tokio::test]
async fn create_table_rejects_bad_schema() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// ① 撞内置表(`base_user` 在 `schema.sql` 里)⇒ 名称不能重复。
let body = create_body(
"base_user",
"用户表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["code"], 400, "{resp}");
assert_eq!(resp["msg"], "名称不能重复", "{resp}");
// ② 一个主键都没选。
let body = create_body(
"it7_no_pk",
"无主键",
vec![field("a", "a", "varchar", json!(10), false, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "请选择一个字段作为主键", "{resp}");
// ③ 类型不在官方那 7 个编码里。
let body = create_body(
"it7_bad_type",
"类型错",
vec![field("a", "a", "blob", json!(10), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "列名a的类型不支持", "{resp}");
// ④ 列名带空格 ⇒ 白名单拒绝(这也是**唯一**能把字符串拼进 DDL 的入口)。
let body = create_body(
"it7_bad_col",
"列名错",
vec![field("a b", "x", "varchar", json!(10), true, false)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["msg"], "列名格式错误,请重新输入", "{resp}");
// ⑤ 自增必须是整形(官方 `checkPrimary`)。
let body = create_body(
"it7_bad_identity",
"自增错",
vec![field("id", "主键", "varchar", json!(32), true, true)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(
resp["msg"], "自增长ID字段数据类型必须为整形或长整型",
"{resp}"
);
// ⑥ 合法自增(`int` + 主键)⇒ 建得出来,且读回 `identity=1`。
let body = create_body(
"it7_identity_ok",
"自增表",
vec![field("id", "主键", "int", json!(0), true, true)],
);
let (_, resp) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(resp["code"], 200, "int 主键自增应建得出来: {resp}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_identity_ok",
&token,
None,
)
.await;
let id = &info["data"]["tableFieldList"][0];
assert_eq!(id["identity"], 1, "`GENERATED BY DEFAULT AS IDENTITY` 要读回 1: {id}");
assert_eq!(id["primaryKey"], 1, "{id}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_identity_ok",
&token,
None,
)
.await;
}
// ---------------------------------------------------------------- 内置表护栏
/// 内置表**只给看**:改不行、删不行(少了这道闸,点一下就 `base_user` 没了)。
#[tokio::test]
async fn builtin_tables_cannot_be_altered_or_dropped() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let (_, del) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/base_user",
&token,
None,
)
.await;
assert_eq!(del["code"], 400, "{del}");
assert_eq!(del["msg"], "系统自带表,不允许被删除", "官方 DB101: {del}");
let body = create_body(
"base_user",
"用户表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["code"], 400, "{upd}");
assert_eq!(upd["msg"], "系统自带表,不允许被编辑", "官方 DB102: {upd}");
// 业务表(`demo_item`)也在 DDL 里 ⇒ 同样受保护。
let (_, del2) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/demo_item",
&token,
None,
)
.await;
assert_eq!(del2["msg"], "系统自带表,不允许被删除", "{del2}");
}
// ---------------------------------------------------------------- 改表
/// `update` = 重建表:改名 + 加列 + 去列,旧表必须消失。
#[tokio::test]
async fn update_rebuilds_table_and_renames() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_u_old",
"改表前",
vec![
field("id", "主键", "varchar", json!(32), true, false),
field("gone", "将被删的列", "varchar", json!(16), false, false),
],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
let body = json!({
"tableInfo": { "table": "it7_u_old", "tableName": "改表后", "newTable": "it7_u_new" },
"tableFieldList": [
field("id", "主键", "varchar", json!(32), true, false),
field("added", "新列", "varchar", json!(64), false, false),
],
})
.to_string();
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["code"], 200, "改表应成功: {upd}");
assert_eq!(upd["data"], "修改成功", "{upd}");
let (_, old) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_u_old",
&token,
None,
)
.await;
assert_eq!(old["code"], 400, "旧表必须已消失: {old}");
let (_, new) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_u_new",
&token,
None,
)
.await;
assert_eq!(new["code"], 200, "{new}");
assert_eq!(new["data"]["tableInfo"]["tableName"], "改表后", "{new}");
let names: Vec<&str> = new["data"]["tableFieldList"]
.as_array()
.expect("字段必须是数组")
.iter()
.filter_map(|f| f["field"].as_str())
.collect();
assert_eq!(names, vec!["id", "added"], "字段应该是请求里的那一套: {new}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_u_new",
&token,
None,
)
.await;
}
/// `addFields` 只追加:**不要求主键**、旧列一个不动。
#[tokio::test]
async fn add_fields_only_appends_and_needs_no_primary_key() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let body = create_body(
"it7_add",
"加字段",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
// 🔴 请求里**没有主键字段** —— 主键早就在表上,要求它会让「加一列」永远失败。
let body = json!({
"tableInfo": { "table": "it7_add", "tableName": "加字段", "newTable": "it7_add" },
"tableFieldList": [ field("extra", "追加列", "varchar", json!(64), false, false) ],
})
.to_string();
let (_, added) = call(
port,
"PUT",
"/api/system/DataModel/0/addFields",
&token,
Some(&body),
)
.await;
assert_eq!(added["code"], 200, "加字段应成功: {added}");
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_add",
&token,
None,
)
.await;
let names: Vec<&str> = info["data"]["tableFieldList"]
.as_array()
.expect("字段必须是数组")
.iter()
.filter_map(|f| f["field"].as_str())
.collect();
assert_eq!(names, vec!["id", "extra"], "旧列不能被删: {info}");
// 同一个字段再加一次 ⇒ `ADD COLUMN IF NOT EXISTS` ⇒ 不报错、不重复。
let (_, again) = call(
port,
"PUT",
"/api/system/DataModel/0/addFields",
&token,
Some(&body),
)
.await;
assert_eq!(again["code"], 200, "重复加同一列应幂等: {again}");
let _ = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_add",
&token,
None,
)
.await;
}
// ---------------------------------------------------------------- 有数据的表
/// 表里**有数据** ⇒ 改结构 / 删表一律拒(官方 DB202 / DB201)。
#[tokio::test]
async fn table_with_data_is_frozen() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// `base_data_type` 有 7 行种子 ⇒ 复制一份带数据的表。
let body = json!({ "table": "it7_copy_full", "tableName": "带数据副本", "type": 1 }).to_string();
let (_, copied) = call(
port,
"POST",
"/api/system/DataModel/0/Table/base_data_type/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(copied["code"], 200, "复制应成功: {copied}");
let (_, preview) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full/Preview",
&token,
None,
)
.await;
assert_eq!(
preview["data"]["pagination"]["total"], 7,
"`type=1` 必须把数据一起搬过去: {preview}"
);
let (_, info) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full",
&token,
None,
)
.await;
assert_eq!(info["data"]["hasTableData"], true, "{info}");
let (_, del) = call(
port,
"DELETE",
"/api/system/DataModel/0/Table/it7_copy_full",
&token,
None,
)
.await;
assert_eq!(del["msg"], "表已经被使用,不允许被删除", "官方 DB201: {del}");
let body = json!({
"tableInfo": { "table": "it7_copy_full", "tableName": "x", "newTable": "it7_copy_full2" },
"tableFieldList": [ field("id", "主键", "varchar", json!(32), true, false) ],
})
.to_string();
let (_, upd) = call(
port,
"PUT",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(upd["msg"], "表已经被使用,不允许被编辑", "官方 DB202: {upd}");
// 重建表会连带数据一起没 ⇒ 确认「拒了之后表和数据都还在」。
let (_, still) = call(
port,
"GET",
"/api/system/DataModel/0/Table/it7_copy_full/Preview",
&token,
None,
)
.await;
assert_eq!(still["data"]["pagination"]["total"], 7, "拒了就不许动数据: {still}");
}
/// `Copy` 的重名 / 源不存在;`deleteAllTable` 只清**非内置**表。
#[tokio::test]
async fn copy_guards_and_delete_all_spares_builtin() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
// 源表不存在。
let body = json!({ "table": "it7_x", "tableName": "x", "type": 0 }).to_string();
let (_, missing) = call(
port,
"POST",
"/api/system/DataModel/0/Table/no_such_table_7/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(missing["msg"], "获取失败,表不存在", "{missing}");
// 复制一张空表,再撞它的名字 ⇒ 官方 VS032。
let body = create_body(
"it7_src",
"源表",
vec![field("id", "主键", "varchar", json!(32), true, false)],
);
let (_, created) = call(
port,
"POST",
"/api/system/DataModel/0/Table",
&token,
Some(&body),
)
.await;
assert_eq!(created["code"], 200, "{created}");
let body = json!({ "table": "it7_src_copy", "tableName": "副本", "type": 0 }).to_string();
let (_, ok_copy) = call(
port,
"POST",
"/api/system/DataModel/0/Table/it7_src/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(ok_copy["code"], 200, "{ok_copy}");
let (_, dup) = call(
port,
"POST",
"/api/system/DataModel/0/Table/it7_src/Actions/Copy",
&token,
Some(&body),
)
.await;
assert_eq!(
dup["msg"], "数据库表名在整个数据库中应保持唯一",
"官方 VS032: {dup}"
);
// `deleteAllTable` 的 dbType 必须与库一致。
let (_, bad) = call(
port,
"DELETE",
"/api/system/DataModel/0/deleteAllTable?dbType=MySQL",
&token,
None,
)
.await;
assert_eq!(bad["msg"], "数据库类型不符", "{bad}");
let (_, cleared) = call(
port,
"DELETE",
"/api/system/DataModel/0/deleteAllTable?dbType=PostgreSQL",
&token,
None,
)
.await;
assert_eq!(cleared["code"], 200, "{cleared}");
// 🔴 清空的只是**非内置**表:`base_user` / `demo_item` 必须都还在。
let (_, list) = call(
port,
"GET",
"/api/system/DataModel/0/Tables?pageSize=100",
&token,
None,
)
.await;
let names: Vec<String> = list["data"]["list"]
.as_array()
.expect("表清单必须是数组")
.iter()
.filter_map(|t| t["table"].as_str().map(str::to_string))
.collect();
assert!(names.contains(&"base_user".to_string()), "内置表被误删: {names:?}");
assert!(names.contains(&"demo_item".to_string()), "业务表被误删: {names:?}");
assert!(
!names.contains(&"it7_src".to_string()),
"自建表应被清掉: {names:?}"
);
}
// ---------------------------------------------------------------- 导出 / 导入
/// `Export` / `Import` **恒失败**,且说的是人话(不返假下载地址、不假装收下文件)。
#[tokio::test]
async fn export_and_import_fail_honestly() {
let _guard = LOCK.lock().await;
let port = serve(new_state(db().await)).await;
let token = login(port).await;
let (status, export) = call(
port,
"GET",
"/api/system/DataModel/0/Table/base_user/Actions/Export",
&token,
None,
)
.await;
assert!(status.contains("200"), "业务失败也必须 HTTP 200: {status}");
assert_eq!(export["code"], 400, "{export}");
assert!(
export["msg"].as_str().unwrap_or_default().contains("导出"),
"要说明白不支持什么: {export}"
);
let (_, import) = call(
port,
"POST",
"/api/system/DataModel/0/Actions/Import",
&token,
None,
)
.await;
assert_eq!(import["code"], 400, "{import}");
assert!(
import["msg"].as_str().unwrap_or_default().contains("导入"),
"{import}"
);
}