按官方三源(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 行)。
857 lines
30 KiB
Rust
857 lines
30 KiB
Rust
//! 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("清理失败");
|
||
}
|