Files
ssw-platform/src/backend/tests/crud_it.rs
T
admin 1c224b7b79 feat(core): 补齐 core 族 22 条端点并同步契约三处
按官方三源(LoginController / UtilsController / LocationController +
官方前端 api/core/*.ts)逐条核对,实现 22 条 core 端点:
- 真实现 6 条:锁屏解锁、免密登录票据、扫码凭证状态流转
- 诚实失败 16 条:文件族 4 + 导入族 4 + 地图族 3 + 改密通知 1
  + SaaS 族 3 + socials 1(无文件存储 / 无导入引擎 / 无地图服务 /
  无邮件短信通道 / 无多租户切库 / 无第三方账号 ⇒ code=400 + 人话,
  不返假 URL、不返假坐标)

新增 TicketStore(进程内内存票据表,官方用 Redis 而本仓无 Redis):
两种票据带前缀隔离(tkt- / scc-),不互相串用。

同批修掉一个真偏差:Login/saas 原先写成 let _ = require_login_face_b(..)
丢弃了 Err ⇒ 实际不拦,但静态闸门推成「登录」⇒ 契约标签与运行时行为
不符;已改成真拦(官方 TenantSaasGranter.checkTenantUser 要求已有登录态)。

契约三处同步:[ENDPOINT] +22 / [OFFICIAL] +22 / [FACE] 面 B 558→580,
并顺手修正契约 §6 头两个无人校验的散文数字(132→610 条、53→607 行)。
2026-11-02 17:34:03 +08:00

857 lines
30 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.
//! crud 集成测试 —— spec 驱动的通用 CRUD 引擎 + demo / shop / books 三个业务模块。
//!
//! 🔴 pglite-rs 0.2.7 是**进程级全局标志**:一个进程一辈子只能开一个实例
//! (第二次 `open()` ⇒ `Error::AlreadyOpen`)⇒ 全文件**共用一个临时库**
//! (`OnceCell` 起一次),不每个测试函数各开一个(裁决 S11)。
//!
//! 🔴 **测试之间必须串行**:Rust 的 test harness 把同一个 `tests/*.rs` 里的
//! `#[tokio::test]` **并发**跑 ⇒ 共用一个库时它们会互相踩数据
//! ⇒ 用一把进程级 `tokio::sync::Mutex` 把每个测试**整体**串起来。
//!
//! 🔴 **不依赖测试执行顺序**:每个测试用**自己专属**的标题 / id;
//! 需要「不存在」前置条件的 ⇒ 自己先 `DELETE` 造出前置条件再断言。
use std::path::PathBuf;
use std::sync::Arc;
use axum::body::Bytes;
use axum::extract::{RawQuery, State};
use axum::http::{HeaderMap, HeaderValue};
use serde_json::{json, Value};
use ssw_platform::bootstrap::ensure_base;
use ssw_platform::platform::config::Config;
use ssw_platform::modules::{books, demo, shop};
use ssw_platform::platform::db::Db;
use axum::Json;
use ssw_platform::platform::envelope::ActionResult;
use ssw_platform::platform::seed::first_seed;
use ssw_platform::platform::session::{SessionStore, TicketStore};
use ssw_platform::platform::state::AppState;
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 临时库失败");
ssw_platform::bootstrap::ensure_schema_all(&db)
.await
.expect("ensure_schema_all 失败");
ensure_base(&db).await.expect("ensure_base 失败");
first_seed(&db, "123456").await.expect("first_seed 失败");
db
})
.await
}
/// 造一个应用状态(**每个测试自己一份** ⇒ token 表互不干扰)。
fn new_state(db: &Db) -> AppState {
AppState {
config: Arc::new(Config::from_env(PathBuf::from("/tmp/ssw-platform-crud-it"))),
db: Arc::new(db.clone()),
sessions: Arc::new(SessionStore::new()),
tickets: Arc::new(TicketStore::default()),
}
}
/// 取种子 admin 的用户 id。
async fn admin_id(db: &Db) -> String {
let rows = db
.query_json("SELECT f_id AS \"id\" FROM base_user WHERE f_account = 'admin' LIMIT 1")
.await
.expect("查 admin 失败");
rows.first()
.and_then(|r| r.get("id"))
.and_then(Value::as_str)
.expect("种子里必须有 admin 用户")
.to_string()
}
/// 造一个**管理员** token(管理员短路 ⇒ 菜单守卫直接放行)。
async fn admin_state(db: &Db) -> (AppState, HeaderMap) {
let state = new_state(db);
let id = admin_id(db).await;
let token = state.sessions.issue("admin", &id, 1);
(state, auth_headers(&token))
}
/// 造一个**非管理员** token(`f_is_administrator = 0`、**无任何授权**)。
///
/// 🔴 用来验证「菜单守卫真的会拦人」(裁决 S15):`shop/Product` 与 `books/Book`
/// 这两个菜单 key 已由种子写入 `base_module` ⇒ 非管理员没授权 ⇒ `code=403`。
async fn plain_user_state(db: &Db) -> (AppState, HeaderMap) {
let state = new_state(db);
let user_id = "it_crud_plain_user";
db.exec(&format!(
"DELETE FROM base_user WHERE f_id = '{user_id}'; \
INSERT INTO base_user (f_id, f_account, f_password, f_is_administrator, \
f_enabled_mark, f_delete_mark) \
VALUES ('{user_id}', '{user_id}', 'x', 0, 1, 0)"
))
.await
.expect("造非管理员用户失败");
let token = state.sessions.issue(user_id, user_id, 0);
(state, auth_headers(&token))
}
/// 带 `bearer <token>` 的请求头。
fn auth_headers(token: &str) -> HeaderMap {
let mut headers = HeaderMap::new();
let value =
HeaderValue::from_str(&format!("bearer {}", token)).expect("token 必须是合法 header 值");
headers.insert("authorization", value);
headers
}
/// 空请求头(未登录)。
fn anon_headers() -> HeaderMap {
HeaderMap::new()
}
/// 造一个 query。
fn query(raw: &str) -> RawQuery {
RawQuery(Some(raw.to_string()))
}
/// 造一个**完全没有 query** 的 `RawQuery`(`RawQuery(None)`)。
fn query_none() -> RawQuery {
RawQuery(None)
}
/// 信封的 `data` 必须是对象。
fn data_obj(r: &Json<ActionResult>) -> Value {
assert_eq!(r.0.code, 200, "期望成功,实际 code={}", r.0.code);
r.0.data.clone()
}
/// 信封的 `data` 必须是数组。
fn data_arr(r: &Json<ActionResult>) -> Vec<Value> {
assert_eq!(r.0.code, 200, "期望成功,实际 code={}", r.0.code);
r.0.data.as_array().expect("data 必须是数组").clone()
}
// ---------------------------------------------------------------- Product
/// 新建 Product ⇒ `data.id` 长度 36、**`data.price == "9.90"`(字符串)**。
#[tokio::test]
async fn product_save_creates_product_with_price_as_string() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-产品-1";
db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title, "price": "9.90"}).to_string()),
)
.await;
let data = data_obj(&r);
let id = data["id"].as_str().expect("id 必须是字符串");
assert_eq!(id.len(), 36, "主键必须是 36 位 UUID: {id}");
assert_eq!(data["title"], title);
// 🔴 numeric 列必须序列化成**字符串**(`f_price::text`)。
assert_eq!(data["price"], "9.90", "price 必须是字符串 9.90");
assert!(data["price"].is_string(), "price 必须是 JSON 字符串");
assert_eq!(data["creatorUserId"], "admin");
assert_eq!(data["deleteMark"], 0);
assert!(data["creatorTime"].is_string(), "creatorTime 必须是 ISO 串");
assert!(data["creatorTime"].as_str().unwrap().ends_with('Z'));
}
/// Product 的 `creatorUserId` 取 body(缺省才回落 `'admin'`)。
#[tokio::test]
async fn product_creator_user_id_comes_from_body() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-产品-2";
db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title, "creatorUserId": "someone"}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["creatorUserId"], "someone");
}
/// 路径 1:body 不给 price ⇒ 用 spec 的默认值 `'0.00'`。
#[tokio::test]
async fn product_price_defaults_to_zero() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-产品-3";
db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["price"], "0.00", "缺省 price 必须是 0.00");
}
// ---------------------------------------------------------------- Book
/// 新建 Book(6 个业务字段)⇒ `price == "58.00"`(字符串)、`stock == 100`(**数字**)。
#[tokio::test]
async fn book_save_creates_book_with_string_price_and_numeric_stock() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-书-1";
db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = books::book_save(
State(state.clone()),
headers,
Bytes::from(
json!({
"title": title,
"author": "作者甲",
"isbn": "9780000000001",
"category": "技术",
"price": "58.00",
"stock": 100
})
.to_string(),
),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"].as_str().unwrap().len(), 36);
assert_eq!(data["title"], title);
assert_eq!(data["author"], "作者甲");
assert_eq!(data["isbn"], "9780000000001");
assert_eq!(data["category"], "技术");
assert_eq!(data["price"], "58.00", "price 必须是字符串");
assert!(data["price"].is_string());
// 🔴 int 列保持**数字**。
assert_eq!(data["stock"], 100);
assert!(data["stock"].is_number(), "stock 必须是 JSON 数字");
assert_eq!(data["creatorUserId"], "admin");
assert_eq!(data["deleteMark"], 0);
}
/// 路径 1:Book 不给 price / stock ⇒ `price == "0.00"`、`stock == 0`。
#[tokio::test]
async fn book_price_and_stock_defaults() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-书-2";
db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = books::book_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["price"], "0.00");
assert_eq!(data["stock"], 0);
}
// ---------------------------------------------------------------- DemoItem
/// 新建 DemoItem ⇒ `status == "草稿"`(默认值)、`creatorUserId == "admin"`(**硬编码**)。
#[tokio::test]
async fn demo_item_uses_default_status_and_hardcoded_admin() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-草稿-1";
db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title, "creatorUserId": "someone-else"}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["status"], "草稿", "缺省 status 必须是 草稿");
// 🔴 demo_item 的 creatorUserId **硬编码** `'admin'`(body 给了也忽略)。
assert_eq!(data["creatorUserId"], "admin");
assert_eq!(data["id"].as_str().unwrap().len(), 36);
assert_eq!(data["deleteMark"], 0);
}
// ---------------------------------------------------------------- List / Delete
/// List 只返回未软删的行:Delete 后 list 长度 -1。
#[tokio::test]
async fn list_hides_soft_deleted_rows() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-列表-1";
db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": title}).to_string()),
)
.await;
let data = data_obj(&r);
let id = data["id"].as_str().expect("id").to_string();
let before = data_arr(&shop::product_list(State(state.clone()), headers.clone()).await);
assert!(
before.iter().any(|row| row["id"] == id.as_str()),
"新建的行必须在 list 里"
);
let d = shop::product_delete(
State(state.clone()),
headers.clone(),
query(&format!("id={id}")),
)
.await;
assert_eq!(d.0.code, 200);
assert_eq!(d.0.data, Value::Null, "Delete 的 data 必须是 null");
let after = data_arr(&shop::product_list(State(state.clone()), headers).await);
assert_eq!(
after.len(),
before.len() - 1,
"软删后 list 长度应少 1"
);
assert!(!after.iter().any(|row| row["id"] == id.as_str()));
}
/// Delete 不带 id(解析失败 / 缺失)⇒ **幂等成功**。
#[tokio::test]
async fn delete_without_id_is_idempotent() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let d = shop::product_delete(State(state.clone()), headers.clone(), query_none()).await;
assert_eq!(d.0.code, 200, "缺 id 必须返回成功: code={}", d.0.code);
assert_eq!(d.0.data, Value::Null);
let d2 = shop::product_delete(State(state.clone()), headers, query("id=")).await;
assert_eq!(d2.0.code, 200, "空 id 必须返回成功: code={}", d2.0.code);
}
// ---------------------------------------------------------------- Update
/// 更新:改 title 后读回是新 title,**body 没给的列保持原值**。
#[tokio::test]
async fn update_overwrites_only_given_fields() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-更新-1";
let new_title = "it-更新-1-改";
db.exec(&format!(
"DELETE FROM shop_product WHERE f_title IN ('{title}', '{new_title}')"
))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": title, "price": "12.34"}).to_string()),
)
.await;
let data = data_obj(&r);
let id = data["id"].as_str().expect("id").to_string();
let r2 = shop::product_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"id": id, "title": new_title}).to_string()),
)
.await;
let data2 = data_obj(&r2);
assert_eq!(data2["id"], id.as_str(), "id 不得变");
assert_eq!(data2["title"], new_title, "title 必须被覆盖");
// 🔴 body 没给 price ⇒ **保持原值**(`Object.assign` 语义)。
assert_eq!(data2["price"], "12.34", "price 必须保持原值");
assert_eq!(data2["creatorTime"], data["creatorTime"], "creatorTime 不得被改");
}
// ---------------------------------------------------------------- 路径 2
/// 路径 2:body 有 id 但库里没这行 ⇒ **用该 id 新建**,**不加任何默认值**。
///
/// 🔴 `f_creator_time` ⇒ NULL、`f_status` ⇒ NULL、`f_delete_mark` ⇒ 0。
#[tokio::test]
async fn unknown_id_creates_row_without_defaults() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let given_id = "it-missing-demo-id-1";
db.exec(&format!("DELETE FROM demo_item WHERE f_id = '{given_id}'"))
.await
.expect("清理失败");
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from(json!({"id": given_id, "title": "it-路径2-1"}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"], given_id, "必须用 body 给的 id");
assert_eq!(data["title"], "it-路径2-1");
// 🔴 路径 2 **一个默认值都不加**。
assert_eq!(data["status"], Value::Null, "status 必须是 null");
assert_eq!(data["creatorTime"], Value::Null, "creatorTime 必须是 null");
assert_eq!(data["creatorUserId"], Value::Null, "creatorUserId 必须是 null");
// 🔴 `f_delete_mark` 由 DDL 的 `DEFAULT 0` 补出 ⇒ 0(不是 NULL)。
assert_eq!(data["deleteMark"], 0, "deleteMark 必须是 0");
}
/// 路径 2(Book):`f_stock` 由 DDL 的 `DEFAULT 0` 补出 ⇒ **0**(不是 NULL)。
#[tokio::test]
async fn unknown_id_book_stock_is_zero_by_db_default() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let given_id = "it-missing-book-id-1";
db.exec(&format!("DELETE FROM book_shop_book WHERE f_id = '{given_id}'"))
.await
.expect("清理失败");
let r = books::book_save(
State(state.clone()),
headers,
Bytes::from(json!({"id": given_id}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"], given_id);
assert_eq!(data["stock"], 0, "stock 必须是 DB 默认值补出的 0");
assert_eq!(data["price"], Value::Null, "price 必须是 null(不是 0.00)");
assert_eq!(data["creatorTime"], Value::Null);
assert_eq!(data["deleteMark"], 0);
}
/// 路径 2 的 Price:Product 不给 price ⇒ **NULL**(不是 `'0.00'`)。
#[tokio::test]
async fn unknown_id_product_price_is_null() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let given_id = "it-missing-product-id-1";
db.exec(&format!("DELETE FROM shop_product WHERE f_id = '{given_id}'"))
.await
.expect("清理失败");
let r = shop::product_save(
State(state.clone()),
headers,
Bytes::from(json!({"id": given_id}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["price"], Value::Null, "路径 2 的 price 必须是 null");
assert_eq!(data["deleteMark"], 0);
}
// ---------------------------------------------------------------- 守卫与错误
/// 未登录 ⇒ `code=600`(HTTP 200 + 信封,不是 401)。
#[tokio::test]
async fn anonymous_is_rejected_with_600() {
let db = db().await;
let _guard = LOCK.lock().await;
let state = new_state(db);
let r = shop::product_list(State(state.clone()), anon_headers()).await;
assert_eq!(r.0.code, 600, "未登录必须是 600: code={}", r.0.code);
assert_eq!(r.0.data, Value::Null);
let r2 = demo::demo_item_list(State(state), anon_headers()).await;
assert_eq!(r2.code, 600);
}
/// 非管理员没授权 ⇒ `code=403`(菜单 `shop/Product` **真的**拦人)。
#[tokio::test]
async fn non_admin_without_menu_permission_gets_403() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = plain_user_state(db).await;
let r = shop::product_list(State(state.clone()), headers.clone()).await;
assert_eq!(r.0.code, 403, "无菜单权限必须是 403: code={}", r.0.code);
assert_eq!(r.0.data, Value::Null);
// 🔴 demo 只有「登录」守卫 ⇒ 非管理员**可以**访问。
let r2 = demo::demo_item_list(State(state), headers).await;
assert_eq!(r2.0.code, 200, "demo 仅需登录: code={}", r2.0.code);
}
/// body 解析失败 ⇒ `code=400` + `请求参数格式错误`(不是 axum 的 422 文本)。
#[tokio::test]
async fn malformed_body_is_a_business_error() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let r = shop::product_save(
State(state.clone()),
headers.clone(),
Bytes::from_static(b"{not json"),
)
.await;
assert_eq!(r.0.code, 400, "解析失败必须是 400: code={}", r.0.code);
assert_eq!(r.0.msg, "请求参数格式错误");
assert_eq!(r.0.data, Value::Null);
let r2 = books::book_save(
State(state),
headers,
Bytes::from_static(b"{not json"),
)
.await;
assert_eq!(r2.0.code, 400);
assert_eq!(r2.0.msg, "请求参数格式错误");
}
/// body 里**不属于该实体列集**的键一律忽略(不报错)。
#[tokio::test]
async fn unknown_body_keys_are_ignored() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-忽略键-1";
db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title, "notAColumn": "x", "idOfOther": 1}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["title"], title);
assert!(data.get("notAColumn").is_none());
assert!(data.get("idOfOther").is_none());
}
/// 空 body(`{}`)⇒ 走路径 1(新建),不报错。
#[tokio::test]
async fn empty_body_creates_a_row() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from_static(b"{}"),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"].as_str().unwrap().len(), 36);
assert_eq!(data["status"], "草稿");
assert_eq!(data["title"], Value::Null);
}
/// `id` 为空串 ⇒ **无 id**(走路径 1 新建),不是「更新一条 id='' 的行」。
#[tokio::test]
async fn empty_string_id_is_treated_as_no_id() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from(json!({"id": "", "title": "it-空id-1"}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"].as_str().unwrap().len(), 36, "空 id 必须新建");
assert_eq!(data["title"], "it-空id-1");
}
/// `id` 是数字 ⇒ **有 id**(按 JSON 文本去查)⇒ 查不到 ⇒ 路径 2(用该 id 新建)。
#[tokio::test]
async fn numeric_id_is_treated_as_an_id() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
db.exec("DELETE FROM demo_item WHERE f_id = '12345'")
.await
.expect("清理失败");
let r = demo::demo_item_save(
State(state.clone()),
headers,
Bytes::from(json!({"id": 12345, "title": "it-数字id-1"}).to_string()),
)
.await;
let data = data_obj(&r);
assert_eq!(data["id"], "12345", "数字 id 必须按文本落库");
assert_eq!(data["title"], "it-数字id-1");
}
/// 路径 1 的 JS `??` 语义:body 里**显式 null** ⇒ 回落 spec 的默认值
/// (`status ?? '草稿'` / `price ?? '0.00'`)。
#[tokio::test]
async fn explicit_null_falls_back_to_defaults_in_path_1() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let demo_title = "it-null-默认-1";
let product_title = "it-null-默认-2";
db.exec(&format!(
"DELETE FROM demo_item WHERE f_title = '{demo_title}'; \
DELETE FROM shop_product WHERE f_title = '{product_title}'"
))
.await
.expect("清理失败");
let d = demo::demo_item_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": demo_title, "status": Value::Null}).to_string()),
)
.await;
assert_eq!(data_obj(&d)["status"], "草稿", "null status 必须回落默认值");
let p = shop::product_save(
State(state.clone()),
headers.clone(),
Bytes::from(
json!({"title": product_title, "price": Value::Null, "creatorUserId": Value::Null})
.to_string(),
),
)
.await;
let data = data_obj(&p);
assert_eq!(data["price"], "0.00", "null price 必须回落默认值");
assert_eq!(data["creatorUserId"], "admin", "null creatorUserId 必须回落 admin");
}
/// 路径 1 的 JS `||` 语义:`creatorUserId` 是**空串** ⇒ 回落 `'admin'`。
#[tokio::test]
async fn empty_creator_user_id_falls_back_to_admin() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-空creator-1";
db.exec(&format!("DELETE FROM shop_product WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let p = shop::product_save(
State(state.clone()),
headers,
Bytes::from(json!({"title": title, "creatorUserId": ""}).to_string()),
)
.await;
assert_eq!(data_obj(&p)["creatorUserId"], "admin");
}
/// List 的行键名必须是契约的 camelCase(`title` / `price` / `creatorTime` …)。
#[tokio::test]
async fn list_rows_use_contract_json_keys() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-键名-1";
db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'"))
.await
.expect("清理失败");
let saved = books::book_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": title, "price": "1.00"}).to_string()),
)
.await;
assert_eq!(saved.0.code, 200, "新建失败: code={}", saved.0.code);
let rows = data_arr(&books::book_list(State(state), headers).await);
let row = rows
.iter()
.find(|r| r["title"] == title)
.expect("刚建的行必须在 list 里");
for key in [
"id",
"title",
"author",
"isbn",
"category",
"price",
"stock",
"creatorUserId",
"creatorTime",
"deleteMark",
] {
assert!(row.get(key).is_some(), "缺键 {key}: {row}");
}
}
// ---------------------------------------------------------------- 路径 3
/// 路径 3:body 有 id、**库里查得到** ⇒ 覆盖更新;`f_creator_time` 在契约 §5.3 的列集内
/// ⇒ body 给了 `creatorTime` 就**允许被写入**(写入走 `::timestamp` 转换)。
///
/// 🔴 react 侧的 `Object.assign(existing, item)` 同样会带上 `creatorTime` ⇒ 两版一致。
#[tokio::test]
async fn path3_writes_creator_time_and_keeps_other_columns() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-路径3-时间-1";
db.exec(&format!("DELETE FROM demo_item WHERE f_title = '{title}'"))
.await
.expect("清理失败");
// ---- 第一轮:先把这一行**真的建出来**(路径 3 的判定是「库里查得到该 id」)----
// 🔴 第一轮 body 里**显式给 status**(不是 spec 的默认值 `"草稿"`)——
// 这样第二轮的 status 断言才有鉴别力。
let r = demo::demo_item_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": title, "status": "进行中"}).to_string()),
)
.await;
let first = data_obj(&r);
let id = first["id"].as_str().expect("id 必须是字符串").to_string();
assert_eq!(first["status"], "进行中", "第一轮必须写成 body 给的 status");
// ---- 第二轮:同一个 id + body 里带 creatorTime ⇒ 路径 3 覆盖更新 ----
let r2 = demo::demo_item_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"id": id, "creatorTime": "2026-01-01T00:00:00Z"}).to_string()),
)
.await;
assert_eq!(r2.0.code, 200, "路径 3 必须成功: code={}", r2.0.code);
let data2 = data_obj(&r2);
// 🔴 关键断言:读回的 creatorTime == body 给的值。
assert_eq!(
data2["creatorTime"], "2026-01-01T00:00:00Z",
"creatorTime 必须被写成 body 给的值"
);
// 🔴 同时断言**其它列没被这一轮改动**(防止本测试退化成「只测 creatorTime 变了」)。
assert_eq!(data2["id"], id.as_str(), "id 不得变");
assert_eq!(data2["title"], title, "title 必须保持上一轮的值");
assert_eq!(
data2["status"], "进行中",
"status 不在第二轮的 body 里 ⇒ 不得被改写(更不得被重置成默认值)"
);
// ---- 清理本测试造的那一行(成功路径不留行;断言失败时的残留是「测试失败」的自然结果)----
db.exec(&format!("DELETE FROM demo_item WHERE f_id = '{id}'"))
.await
.expect("清理失败");
}
/// 路径 3 写 **numeric / int 列**的回归测试(复审 M1)。
///
/// 🔴 这条是 UPDATE 占位符 `$n::text{cast}` 的**防回归钉子**:
/// 改回 `$n{cast}` ⇒ PG 把参数**推断成** `numeric` / `integer`
/// ⇒ pglite 拿 `Option<String>` 去绑 ⇒ `code=400`(而不是 200)。
/// 用 `book_shop_book` —— 它同时有 `f_price`(numeric)与 `f_stock`(int)⇒ 一条覆盖两种类型。
#[tokio::test]
async fn path3_writes_numeric_and_int_columns() {
let db = db().await;
let _guard = LOCK.lock().await;
let (state, headers) = admin_state(db).await;
let title = "it-路径3-numeric-1";
db.exec(&format!("DELETE FROM book_shop_book WHERE f_title = '{title}'"))
.await
.expect("清理失败");
// ---- 第一轮:建行(专属 title + price)----
let r = books::book_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"title": title, "price": "1.00"}).to_string()),
)
.await;
let first = data_obj(&r);
let id = first["id"].as_str().expect("id 必须是字符串").to_string();
assert_eq!(first["price"], "1.00", "第一轮的 price 必须是字符串 1.00");
// ---- 第二轮:同一个 id + body 里带 price / stock ⇒ 路径 3 覆盖更新 ----
let r2 = books::book_save(
State(state.clone()),
headers.clone(),
Bytes::from(json!({"id": id, "price": "9.90", "stock": 100}).to_string()),
)
.await;
// 🔴 改前这里是 400 ⇒ 这条断言就是那颗钉子。
assert_eq!(r2.0.code, 200, "路径 3 必须成功: code={}", r2.0.code);
let data2 = data_obj(&r2);
// 🔴 numeric 列读回恒是**字符串**(投影走 `f_price::text AS "price"`)。
assert_eq!(data2["price"], "9.90", "price 必须是字符串 9.90");
assert!(data2["price"].is_string(), "price 必须是 JSON 字符串");
// 🔴 int 列读回是**数字**(不加 `::text`)。
assert_eq!(data2["stock"], 100, "stock 必须是数字 100");
assert!(data2["stock"].is_number(), "stock 必须是 JSON 数字");
// 🔴 body 没给的列保持原值(这一轮只覆盖 body 里出现的列)。
assert_eq!(data2["title"], title, "title 必须保持第一轮的值");
assert_eq!(data2["id"], id.as_str(), "id 不得变");
// ---- 清理本测试造的那一行(成功路径不留行)----
db.exec(&format!("DELETE FROM book_shop_book WHERE f_id = '{id}'"))
.await
.expect("清理失败");
}