//! 端到端整合測試:in-memory SQLite + migrations + `build_router`,tower `oneshot` 直打。
//! Express 對拍 oracle 退役後的接棒安全網——覆蓋核心公開端點、admin 守衛、JWT exp
//! 與 image-proxy 的 SSRF 防護。每個測試自建獨立 DB(互不干擾、可平行)。
use std::fmt::Write as _;
use std::sync::LazyLock;
use axum::http::StatusCode;
use serde_json::{Value, json};
// 架設(test_app / seed / request / owner_token)抽到 tests/common/mod.rs,
// 因為 tests/snapshots.rs 也要用同一份。Rust 的整合測試一個檔案一個 crate,
// 兩邊看不到彼此,不抽出來就得抄兩份——抄兩份的下場是其中一份會慢慢走樣。
mod common;
use common::{get, owner_token, post_json, request, test_app};
/// GALLERY_MANIFEST_PATH 是 process 全域的,而兩個 gallery 測試各自要指到不同檔案。
/// nextest(CI 的跑法)一個測試一個行程,本來就不會撞;但 `cargo test` 是同一個行程內
/// 平行跑 → 互相蓋掉對方的值 → 隨機失敗。cargo-mutants 預設用 `cargo test`,baseline
/// 一失敗就整個停在「cargo test failed in an unmutated tree」什麼都測不了。
/// 用一把鎖把這兩個測試串起來,兩種跑法都成立。
static GALLERY_ENV_LOCK: LazyLock<tokio::sync::Mutex<()>> = LazyLock::new(|| tokio::sync::Mutex::new(()));
// ── 基本可用性 ─────────────────────────────────────────────────
#[tokio::test]
async fn health_ok() {
let (app, _pool) = test_app().await;
let (status, body) = get(&app, "/api/health").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body, Value::String("OK".into()));
}
#[tokio::test]
async fn unknown_path_is_404() {
let (app, _pool) = test_app().await;
let (status, _) = get(&app, "/api/no-such-endpoint").await;
assert_eq!(status, StatusCode::NOT_FOUND);
}
// ── posts 公開讀 ───────────────────────────────────────────────
#[tokio::test]
async fn posts_list_returns_published_only() {
let (app, _pool) = test_app().await;
let (status, body) = get(&app, "/api/posts").await;
assert_eq!(status, StatusCode::OK);
let posts = body["posts"].as_array().expect("posts array");
assert_eq!(posts.len(), 1);
assert_eq!(posts[0]["title"], "公開文章");
assert!(body.to_string().contains("pagination"));
}
#[tokio::test]
async fn post_detail_and_404() {
let (app, _pool) = test_app().await;
let (status, body) = get(&app, "/api/posts/1").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["title"], "公開文章");
assert_eq!(body["content"], "這是內文");
let (status, body) = get(&app, "/api/posts/999").await;
assert_eq!(status, StatusCode::NOT_FOUND);
assert_eq!(body["message"], "Post not found");
}
#[tokio::test]
async fn post_view_and_like_counters() {
let (app, pool) = test_app().await;
let (status, _) = post_json(&app, "/api/posts/1/view", json!({})).await;
assert_eq!(status, StatusCode::OK);
let (status, _) = post_json(&app, "/api/posts/1/view", json!({})).await;
assert_eq!(status, StatusCode::OK);
let views: i64 =
sqlx::query_scalar("SELECT view_count FROM posts WHERE id = 1").fetch_one(&pool).await.unwrap();
assert_eq!(views, 2);
let (status, body) = post_json(&app, "/api/posts/1/like", json!({})).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["likes"], 1);
let (status, body) = post_json(&app, "/api/posts/1/unlike", json!({})).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["likes"], 0);
// 不存在的文章:view 回 404
let (status, _) = post_json(&app, "/api/posts/999/view", json!({})).await;
assert_eq!(status, StatusCode::NOT_FOUND);
}
#[tokio::test]
async fn post_reactions_upsert() {
let (app, _pool) = test_app().await;
let (status, body) = post_json(&app, "/api/posts/1/reactions", json!({ "emoji": "👍" })).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["emoji"], "👍");
assert_eq!(body["count"], 1);
let (status, body) = post_json(&app, "/api/posts/1/reactions", json!({ "emoji": "💀" })).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body["error"], "invalid emoji");
}
// ── 留言 ──────────────────────────────────────────────────────
#[tokio::test]
async fn anonymous_comment_goes_to_pending() {
let (app, _pool) = test_app().await;
let (status, body) =
post_json(&app, "/api/posts/1/comments", json!({ "author": "路人", "content": "推一個" })).await;
assert_eq!(status, StatusCode::CREATED);
assert_eq!(body["message"], "success");
assert_eq!(body["status"], "pending");
// 缺 author/content → 400
let (status, _) = post_json(&app, "/api/posts/1/comments", json!({ "author": "路人" })).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
}
// ── 其他公開讀 ─────────────────────────────────────────────────
#[tokio::test]
async fn categories_tags_thoughts_books_stats() {
let (app, _pool) = test_app().await;
for (path, expect) in [
("/api/categories", "技術"),
("/api/tags", "rust"),
("/api/thoughts", "第一則碎念"),
("/api/stats", ""),
] {
let (status, body) = get(&app, path).await;
assert_eq!(status, StatusCode::OK, "{path}");
assert!(body.to_string().contains(expect), "{path} 應包含 {expect}");
}
let (status, body) = get(&app, "/api/books").await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["books"], json!([]));
}
/// 計數必須跟列表算同一套語系規則。
///
/// 回歸:`/api/posts?lang=` 會濾掉沒該語系譯文的文章,但 categories/tags 的 post_count 與
/// pagination.total 原本都沒濾 → 側欄顯示「4 篇」點進去卻是空的,分頁也會多出翻不滿的空白頁。
#[tokio::test]
async fn counts_match_the_locale_filtered_list() {
let (app, pool) = test_app().await;
// seed 只有一篇 zh-TW 的「公開文章」(分類技術、標籤 rust)。再加一篇有 ja 譯文的。
sqlx::query(
"INSERT INTO posts (id, title, content, category, status, title_ja, content_ja) \
VALUES (3, '有日文的文章', '中文內文', '技術', 'published', '日本語の記事', '日本語の本文')",
)
.execute(&pool)
.await
.unwrap();
// 不帶 lang:兩篇都算。
let (_, body) = get(&app, "/api/posts").await;
assert_eq!(body["posts"].as_array().unwrap().len(), 2);
assert_eq!(body["pagination"]["total"], 2);
let (_, body) = get(&app, "/api/categories").await;
assert_eq!(body["categories"][0]["post_count"], 2);
// lang=ja:只有 id=3 有日文 → 列表、total、分類計數三者都要是 1。
let (_, body) = get(&app, "/api/posts?lang=ja").await;
let posts = body["posts"].as_array().unwrap();
assert_eq!(posts.len(), 1, "ja 只有一篇有譯文");
assert_eq!(posts[0]["title"], "日本語の記事");
assert_eq!(body["pagination"]["total"], 1, "total 要跟列表長度一致,否則分頁會開出空白頁");
let (_, body) = get(&app, "/api/categories?lang=ja").await;
let tech = body["categories"].as_array().unwrap().iter().find(|c| c["name"] == "技術").expect("技術");
assert_eq!(tech["post_count"], 1, "分類計數要跟 ja 列表一致");
// 沒有任何 ja 文章的語系:分類仍要回傳(LEFT JOIN 不能退化成 INNER),只是計數 0,
// 由前端的 post_count > 0 隱藏。
let (_, body) = get(&app, "/api/categories?lang=ko").await;
let tech =
body["categories"].as_array().unwrap().iter().find(|c| c["name"] == "技術").expect("ko 也要有這列");
assert_eq!(tech["post_count"], 0);
// 標籤:rust 只掛在沒有 ja 譯文的 id=1 上 → ja 下計數 0,被 HAVING 收掉。
let (_, body) = get(&app, "/api/tags").await;
assert_eq!(body["tags"][0]["post_count"], 1);
let (_, body) = get(&app, "/api/tags?lang=ja").await;
assert_eq!(body["tags"].as_array().unwrap().len(), 0, "ja 下沒有文章的標籤不該出現");
}
// ── newsletter 全流程 ──────────────────────────────────────────
#[tokio::test]
async fn newsletter_subscribe_and_unsubscribe_flow() {
let (app, pool) = test_app().await;
let (status, _) = post_json(
&app,
"/api/newsletter/subscribe",
json!({ "email": "reader@example.com", "name": "讀者" }),
)
.await;
assert_eq!(status, StatusCode::CREATED);
let token: String = sqlx::query_scalar(
"SELECT unsubscribe_token FROM newsletter_subscribers WHERE email = 'reader@example.com'",
)
.fetch_one(&pool)
.await
.unwrap();
let (status, body) = get(&app, &format!("/api/newsletter/by-token/{token}")).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["email"], "reader@example.com");
assert_eq!(body["status"], "active");
let (status, _) = post_json(&app, "/api/newsletter/unsubscribe", json!({ "token": token })).await;
assert_eq!(status, StatusCode::OK);
let (_, body) = get(&app, &format!("/api/newsletter/by-token/{token}")).await;
assert_eq!(body["status"], "unsubscribed");
// 壞 token → 404;壞 email 格式 → 400
let (status, _) = get(&app, "/api/newsletter/by-token/nope").await;
assert_eq!(status, StatusCode::NOT_FOUND);
let (status, _) = post_json(&app, "/api/newsletter/subscribe", json!({ "email": "not-an-email" })).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
}
// ── admin 守衛與 JWT ───────────────────────────────────────────
#[tokio::test]
async fn admin_routes_require_bearer() {
let (app, _pool) = test_app().await;
for path in ["/api/admin/posts", "/api/admin/comments", "/api/admin/stats", "/api/admin/users"] {
let (status, body) = get(&app, path).await;
assert_eq!(status, StatusCode::UNAUTHORIZED, "{path}");
assert!(body["message"].is_string(), "{path} 401 應帶 message");
}
}
#[tokio::test]
async fn admin_allows_valid_owner_token() {
let (app, _pool) = test_app().await;
let token = owner_token(true);
let (status, body) = request(&app, "GET", "/api/admin/posts", None, Some(&token)).await;
assert_eq!(status, StatusCode::OK);
// admin 列表看得到草稿
assert!(body.to_string().contains("未發布草稿"));
}
#[tokio::test]
async fn jwt_without_exp_is_rejected() {
let (app, _pool) = test_app().await;
let token = owner_token(false);
let (status, _) = request(&app, "GET", "/api/admin/posts", None, Some(&token)).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
}
#[tokio::test]
async fn jwt_wrong_secret_is_rejected() {
let (app, _pool) = test_app().await;
let now = koimsurai_web_backend::util::now_secs();
let token = jsonwebtoken::encode(
&jsonwebtoken::Header::default(),
&json!({ "username": "admin", "iat": now, "exp": now + 3600 }),
&jsonwebtoken::EncodingKey::from_secret(b"wrong-secret"),
)
.unwrap();
let (status, _) = request(&app, "GET", "/api/admin/posts", None, Some(&token)).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
}
// ── SSRF 防護(image-proxy / link-preview)────────────────────
#[tokio::test]
async fn image_proxy_blocks_internal_targets() {
let (app, _pool) = test_app().await;
for target in [
"http://127.0.0.1/x.png",
"http://169.254.169.254/latest/meta-data",
"http://10.0.0.5/a.jpg",
"http://192.168.1.1/a.jpg",
"http://localhost:8000/a.jpg",
"file:///etc/passwd",
"http://[::1]/a.jpg",
] {
let encoded = urlencode(target);
let (status, body) = get(&app, &format!("/api/image-proxy?url={encoded}")).await;
assert_eq!(status, StatusCode::BAD_REQUEST, "{target} 應被擋");
assert_eq!(body, Value::String("Invalid image URL".into()), "{target}");
}
// 缺 url → 400(對齊 Express 訊息)
let (status, body) = get(&app, "/api/image-proxy").await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, Value::String("Missing image URL".into()));
}
#[tokio::test]
async fn link_preview_rejects_bad_urls_with_empty_card() {
let (app, _pool) = test_app().await;
for target in ["ftp://example.com/x", "http://127.0.0.1/", "not a url"] {
let encoded = urlencode(target);
let (status, body) = get(&app, &format!("/api/link-preview?url={encoded}")).await;
assert_eq!(status, StatusCode::OK, "{target} 降級卡仍回 200");
assert_eq!(body["title"], Value::Null, "{target}");
assert_eq!(body["image"], Value::Null, "{target}");
}
}
/// Trakt 同步每 6 小時把整份觀看歷史重插一次,靠 `INSERT OR IGNORE` 去重。
/// 這個測試釘住「OR IGNORE 真的有東西可 ignore」——0001 的 inline UNIQUE 有兩個洞
/// (見 migrations/0009 的說明),其中 NULL 日期那個在純 SQL 層就能重現。
#[tokio::test]
async fn watch_history_sync_is_idempotent() {
let (_app, pool) = test_app().await;
// 同一批資料插三次,模擬三輪同步
for _ in 0..3 {
for (title, date) in
[("沙丘", Some("2026-07-01")), ("異星入境", None::<&str>), ("沙丘", Some("2026-07-02"))]
{
sqlx::query(
"INSERT OR IGNORE INTO film_history (title, watched_date, source) VALUES (?, ?, 'trakt')",
)
.bind(title)
.bind(date)
.execute(&pool)
.await
.unwrap();
}
for (show, ep, date) in [
("影集A", Some("S01E01"), Some("2026-07-01")),
("影集A", Some("S01E02"), None::<&str>),
("影集B", None::<&str>, None::<&str>),
] {
sqlx::query(
"INSERT OR IGNORE INTO tv_history (series_name, episode_label, watched_date, source) \
VALUES (?, ?, ?, 'trakt')",
)
.bind(show)
.bind(ep)
.bind(date)
.execute(&pool)
.await
.unwrap();
}
}
let films: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM film_history").fetch_one(&pool).await.unwrap();
let tv: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM tv_history").fetch_one(&pool).await.unwrap();
assert_eq!(films, 3, "三輪同步後 film_history 應該只有 3 筆(含一筆 NULL 日期)");
assert_eq!(tv, 3, "三輪同步後 tv_history 應該只有 3 筆(含 NULL 集數/日期)");
// 同片名不同日期要視為兩筆(重看),不能被誤併
let dune: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM film_history WHERE title = '沙丘'")
.fetch_one(&pool)
.await
.unwrap();
assert_eq!(dune, 2, "同片名不同觀看日是兩筆,不該被去重掉");
}
/// 解不出數字的 limit 不能讓公開端點 500。
///
/// 原本綁的是 `Option::<i64>::None`,註解寫「LIMIT NULL=無限制」——那是錯的:
/// SQLite 對 `LIMIT NULL` 回 `(code: 20) datatype mismatch`,於是
/// `GET /api/films/recent?limit=abc` 這種免認證請求就 500。三支 watch 端點都中。
///
/// 這是 schemathesis 從 OpenAPI spec 自動生輸入撞出來的——手寫測試不會想到去試
/// `limit=%F0%97%99%8C`,而且真正的觸發條件比那還寬:任何非數字都會。
#[tokio::test]
async fn watch_limit_never_500s_on_garbage() {
let (app, _pool) = test_app().await;
// 空字串與缺省走「用預設值」那條;其餘都該解不出數字 → 無上限,而不是 500
let garbage = ["abc", "%F0%97%99%8C", "99999999999999999999", "-", "+", "1e5", "NaN", "null"];
for path in ["/api/anime/history", "/api/films/recent", "/api/tv/recent"] {
for v in garbage {
let (status, body) = get(&app, &format!("{path}?limit={v}")).await;
assert_eq!(status, StatusCode::OK, "{path}?limit={v} 不該 500(回應:{body})");
}
// 正常值仍要生效
let (status, _) = get(&app, &format!("{path}?limit=1")).await;
assert_eq!(status, StatusCode::OK, "{path} 正常 limit 也要能用");
}
}
/// `ref` 從自由格式的 Value 改成 `ThoughtRef` 之後的回歸網:link 形狀取自線上那兩則
/// 碎念,media 形狀照 `enrich_media_ref` 實際會寫出的 key。壞掉的 ref_json 要落回
/// `ref: null` 但 `ref_json` 原字串仍在——不能靜靜掉資料。
#[tokio::test]
async fn thoughts_ref_keeps_link_and_media_shapes() {
let (app, pool) = test_app().await;
for (content, ref_type, ref_url, ref_json) in [
(
"帶連結的碎念",
"link",
"https://example.com/a",
r#"{"title":"100 METERS","desc":"某段簡介","image":"https://img/x.jpg","site":"The Movie Database"}"#,
),
(
"帶 TMDb 卡片的碎念",
"media",
"https://www.themoviedb.org/movie/123",
r#"{"tmdbId":123,"mediaType":"movie","kind":"電影","source":"www.themoviedb.org",
"url":"https://www.themoviedb.org/movie/123","title":"沙丘","overview":"簡介",
"rating":"8.1","genres":"科幻, 冒險","year":"2021","poster":"https://img/p.jpg"}"#,
),
("ref_json 壞掉的碎念", "link", "https://example.com/b", r#"{"title":12345}"#),
] {
sqlx::query("INSERT INTO thoughts (content, ref_type, ref_url, ref_json) VALUES (?, ?, ?, ?)")
.bind(content)
.bind(ref_type)
.bind(ref_url)
.bind(ref_json)
.execute(&pool)
.await
.unwrap();
}
let (status, body) = get(&app, "/api/thoughts").await;
assert_eq!(status, StatusCode::OK);
let by_content = |c: &str| -> Value {
body["thoughts"]
.as_array()
.unwrap()
.iter()
.find(|t| t["content"] == c)
.unwrap_or_else(|| panic!("找不到「{c}」"))
.clone()
};
let link = by_content("帶連結的碎念");
assert_eq!(link["ref"]["title"], "100 METERS");
assert_eq!(link["ref"]["site"], "The Movie Database");
assert_eq!(link["ref"]["image"], "https://img/x.jpg");
// link 沒有 media 那組欄位 → 補成 null,而不是整筆解析失敗
assert_eq!(link["ref"]["poster"], Value::Null);
let media = by_content("帶 TMDb 卡片的碎念");
assert_eq!(media["ref"]["kind"], "電影");
assert_eq!(media["ref"]["genres"], "科幻, 冒險");
assert_eq!(media["ref"]["poster"], "https://img/p.jpg");
// rating / year 是 enrich 寫的字串;tmdbId 是呼叫端帶進來的數字——同一個 union 兩邊都要活著
assert_eq!(media["ref"]["rating"], "8.1");
assert_eq!(media["ref"]["year"], "2021");
assert_eq!(media["ref"]["tmdbId"], 123);
let broken = by_content("ref_json 壞掉的碎念");
assert_eq!(broken["ref"], Value::Null, "形狀不符要落回 null");
assert_eq!(broken["ref_json"], r#"{"title":12345}"#, "原字串仍要原封不動回去");
}
/// fixture 的每個 key/value 都要在回應裡原封不動出現——型別化不能吃掉資料。
/// 反過來允許回應多出 key:Rust 的 `Option` 序列化成 null,把缺的欄位補齊是預期行為。
fn assert_no_data_loss(orig: &Value, got: &Value, path: &str) {
match orig {
Value::Object(o) => {
let g = got.as_object().unwrap_or_else(|| panic!("{path} 不是物件:{got}"));
for (k, v) in o {
let gv = g.get(k).unwrap_or_else(|| panic!("{path}.{k} 不見了"));
assert_no_data_loss(v, gv, &format!("{path}.{k}"));
}
}
Value::Array(a) => {
let g = got.as_array().unwrap_or_else(|| panic!("{path} 不是陣列:{got}"));
assert_eq!(a.len(), g.len(), "{path} 長度不同");
for (i, v) in a.iter().enumerate() {
assert_no_data_loss(v, &g[i], &format!("{path}[{i}]"));
}
}
_ => assert_eq!(orig, got, "{path} 的值被改掉了"),
}
}
fn photo_by_id<'a>(body: &'a Value, id: &str) -> &'a Value {
body["photos"]
.as_array()
.unwrap_or_else(|| panic!("photos 不是陣列:{body}"))
.iter()
.find(|p| p["id"] == id)
.unwrap_or_else(|| panic!("找不到 {id}"))
}
/// manifest 型別化的回歸網:拿線上那份 manifest 的真實形狀(去識別化後)餵進端點,
/// 驗「一個 key 都沒掉」。舊 Node builder 寫的 exif 是 exiftool 的格式化字串、Rust
/// sync 寫的是數字,同一份檔案裡兩種混著——這正是最容易被一個過嚴的 struct 吃掉的地方。
#[tokio::test]
async fn gallery_photos_preserves_legacy_manifest_shape() {
// env var 是 process 全域的 → 跟另一個 gallery 測試互斥(見 GALLERY_ENV_LOCK)
let _env = GALLERY_ENV_LOCK.lock().await;
let fixture = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/gallery_manifest.json");
unsafe { std::env::set_var("GALLERY_MANIFEST_PATH", fixture) };
let (app, _pool) = test_app().await;
let (status, body) = get(&app, "/api/gallery/photos").await;
assert_eq!(status, StatusCode::OK);
let raw: Value = serde_json::from_str(&std::fs::read_to_string(fixture).unwrap()).unwrap();
assert_no_data_loss(&raw, &body, "manifest");
// 混型別的 exif 兩種都要活著
assert!(photo_by_id(&body, "fixture-1-legacy-string-exif")["exif"]["FNumber"].is_string());
assert!(photo_by_id(&body, "fixture-2-numeric-exif")["exif"]["FNumber"].is_number());
// 整數不能變成 100.0:manifest 會被反覆讀寫,序列化不該順手改掉數字寫法
let legacy = photo_by_id(&body, "fixture-1-legacy-string-exif");
assert!(legacy["exif"]["ISO"].is_i64(), "ISO 應維持整數:{}", legacy["exif"]["ISO"]);
assert!(legacy["shootTime"].is_i64(), "shootTime 應維持整數:{}", legacy["shootTime"]);
// 缺 description/tags/tagsEn 的舊資料不該讓整張照片被丟掉
let bare = photo_by_id(&body, "fixture-6-no-tags-no-description");
assert_eq!(bare["description"], "");
assert_eq!(bare["tags"], json!([]));
assert_eq!(bare["tagsEn"], json!([]));
assert_eq!(bare["exif"], Value::Null);
}
/// 一張形狀壞掉的照片只丟那一張,不該讓整個相簿 500——manifest 是外部檔案,
/// 沒有任何東西保證每一列都齊。
#[tokio::test]
async fn gallery_photos_skips_broken_photo_instead_of_failing() {
// 同上:env var 全域 → 與另一個 gallery 測試互斥
let _env = GALLERY_ENV_LOCK.lock().await;
let path = std::env::temp_dir().join(format!("koimsurai-manifest-{}.json", std::process::id()));
let good = json!({
"id": "ok", "title": "ok.jpg",
"urls": { "full": "/a.webp", "regular": "/a.webp", "small": "/t.webp", "thumb": "/t.webp" },
"originalUrl": "/a.webp", "thumbnailUrl": "/t.webp",
"width": 1920, "height": 1080, "aspectRatio": 1.7777777777777777,
"size": 123456, "format": "jpeg"
});
// 缺 id/urls/width…:serde 會在這一列失敗
let broken = json!({ "title": "壞掉.jpg", "format": "jpeg" });
std::fs::write(
&path,
json!({ "version": "1.0", "generatedAt": "2026-07-28T00:00:00.000Z",
"totalPhotos": 2, "photos": [good, broken] })
.to_string(),
)
.unwrap();
unsafe { std::env::set_var("GALLERY_MANIFEST_PATH", &path) };
let (app, _pool) = test_app().await;
let (status, body) = get(&app, "/api/gallery/photos").await;
let _ = std::fs::remove_file(&path);
assert_eq!(status, StatusCode::OK);
assert_eq!(body["photos"].as_array().unwrap().len(), 1, "壞掉的那張要被跳過");
assert_eq!(body["photos"][0]["id"], "ok");
// totalPhotos 取實際回傳的張數,不是檔案裡寫的 2
assert_eq!(body["totalPhotos"], 1);
}
/// 後台頁面不進 vitals 統計。
///
/// 排除發生在**讀取端**而不是寫入端:beacon 照收(歷史資料留著、將來想單獨看後台也還在),
/// 但 /api/vitals/stats 要濾掉——編輯器天生會位移,實測混進來會把全站 CLS p75 從 0.031
/// 拉到 0.129,讓文章頁的真實數字整個被蓋掉。
///
/// count 與 poor 分開斷言:p75 是用 count 算 OFFSET 的,兩句 SQL 只要有一句漏了條件,
/// 母體就會不一致——那種錯不會編譯失敗,只會靜靜地算出錯的百分位。
#[tokio::test]
async fn vitals_stats_excludes_admin_pages() {
let (app, pool) = test_app().await;
for (path, value, rating) in [
("/blog/1", 0.01, "good"),
("/admin", 0.4, "poor"),
("/admin/posts", 0.5, "poor"),
("/admin/posts/edit/1", 0.6, "poor"),
] {
let beacon =
json!({ "metric": "CLS", "value": value, "rating": rating, "path": path, "isMobile": false });
let (status, _) = post_json(&app, "/api/vitals", beacon).await;
assert_eq!(status, StatusCode::NO_CONTENT, "{path} 應該照收");
}
let stored: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM web_vitals").fetch_one(&pool).await.unwrap();
assert_eq!(stored, 4, "四筆都要真的寫進資料表");
let (status, body) = get(&app, "/api/vitals/stats").await;
assert_eq!(status, StatusCode::OK);
let cls =
body["metrics"].as_array().unwrap().iter().find(|m| m["metric"] == "CLS").expect("stats 要有 CLS");
assert_eq!(cls["count"], 1, "只算 /blog/1 那筆");
assert_eq!(cls["poor"], 0, "三筆後台的 poor 不該算進來");
assert_eq!(cls["good"], 1);
assert_eq!(cls["p75"], 0.01, "p75 要落在同一個(已排除後台的)母體上");
}
/// CLS 歸因欄位(target / loadState)存得進、太長會截斷、沒帶就是 NULL。
///
/// 這兩欄是診斷 CLS 的唯一手段:Lighthouse 在無節流的本機跑文章頁是 CLS 0,實地卻是 0.129,
/// 所以「哪個元素在動」只能靠真實讀者的瀏覽器回報 largestShiftTarget。
#[tokio::test]
async fn vitals_beacon_stores_cls_attribution() {
let (app, pool) = test_app().await;
let long_target = format!("html>body>{}", "div.wrap>".repeat(60));
assert!(long_target.chars().count() > 200, "這個測試要靠它超過上限才有意義");
for (path, target, load_state, shift_path) in [
// 讀者停在文章頁,但最大位移其實發生在列表頁——這正是實測到的錯誤歸因情境
("/blog/1", Some("aside.blog-sidebar>div.sidebar-section"), Some("loading"), Some("/blog?page=2")),
("/blog/2", Some(long_target.as_str()), Some("complete"), None),
("/blog/3", None, None, None),
] {
let mut b = json!({ "metric": "CLS", "value": 0.2, "rating": "needs-improvement", "path": path });
if let Some(t) = target {
b["target"] = json!(t);
}
if let Some(l) = load_state {
b["loadState"] = json!(l);
}
if let Some(s) = shift_path {
b["shiftPath"] = json!(s);
}
let (status, _) = post_json(&app, "/api/vitals", b).await;
assert_eq!(status, StatusCode::NO_CONTENT);
}
/// (path, target, load_state, shift_path)
type VitalRow = (String, Option<String>, Option<String>, Option<String>);
let rows: Vec<VitalRow> =
sqlx::query_as("SELECT path, target, load_state, shift_path FROM web_vitals ORDER BY path")
.fetch_all(&pool)
.await
.unwrap();
assert_eq!(rows.len(), 3);
assert_eq!(rows[0].1.as_deref(), Some("aside.blog-sidebar>div.sidebar-section"));
assert_eq!(rows[0].2.as_deref(), Some("loading"));
assert_eq!(rows[0].3.as_deref(), Some("/blog"), "shift_path 要去掉 query");
assert_ne!(rows[0].0, "/blog", "path 仍是讀者離開時的位置,兩欄本來就會不同");
let stored = rows[1].1.as_deref().expect("過長的 target 要截斷保留,不是丟掉");
assert_eq!(stored.chars().count(), 200, "截到 200 字元");
assert!(long_target.starts_with(stored), "截斷要留前綴——前綴才認得出是哪個元件");
assert_eq!(rows[2].1, None, "沒帶歸因就是 NULL");
assert_eq!(rows[2].2, None);
assert_eq!(rows[2].3, None);
}
/// 非法 beacon 一律不進資料表。
///
/// 補這個測試是 cargo-mutants 指出來的:原本 vitals.rs 覆蓋率 98.67%,但把 `report_vital`
/// 驗證鏈裡的 `&&` 全部換成 `||`,測試照樣全綠——因為我只送過**合法**的 beacon,從來沒驗過
/// 非法的被擋掉。那條白名單等於沒被測。端點對驗證失敗一律回 204(不給探測者回饋面),
/// 所以只能查資料表。
#[tokio::test]
async fn vitals_beacon_rejects_invalid_payloads() {
let (app, pool) = test_app().await;
let too_long_path = format!("/{}", "a".repeat(250));
let cases: Vec<(&str, Value)> = vec![
("未知 metric", json!({ "metric": "FOO", "value": 1.0, "rating": "good", "path": "/" })),
("未知 rating", json!({ "metric": "CLS", "value": 1.0, "rating": "great", "path": "/" })),
("負值", json!({ "metric": "CLS", "value": -0.1, "rating": "good", "path": "/" })),
("超過上限", json!({ "metric": "LCP", "value": 120_001.0, "rating": "poor", "path": "/" })),
("path 沒有開頭斜線", json!({ "metric": "CLS", "value": 1.0, "rating": "good", "path": "blog/1" })),
("path 過長", json!({ "metric": "CLS", "value": 1.0, "rating": "good", "path": too_long_path })),
];
for (label, body) in cases {
let (status, _) = post_json(&app, "/api/vitals", body).await;
assert_eq!(status, StatusCode::NO_CONTENT, "{label}:驗證失敗也回 204");
let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM web_vitals").fetch_one(&pool).await.unwrap();
assert_eq!(n, 0, "{label}:不該寫進資料表");
}
// 對照組:完全合法的那筆要進得去,證明上面不是因為端點整個壞掉才沒寫
let (status, _) = post_json(
&app,
"/api/vitals",
json!({ "metric": "CLS", "value": 0.05, "rating": "good", "path": "/blog/1" }),
)
.await;
assert_eq!(status, StatusCode::NO_CONTENT);
let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM web_vitals").fetch_one(&pool).await.unwrap();
assert_eq!(n, 1, "合法 beacon 要寫得進去");
}
/// p75 要挑到正確的那一筆樣本。
///
/// 同樣是 cargo-mutants 指出來的:`(count * 75 / 100).min(count - 1)` 這個 offset 算式
/// 可以把 `*` 換成 `+`、`/` 換成 `%` 或 `*`,測試都不會失敗——因為原本只塞了一筆資料,
/// 任何算式得出的 offset 都是 0,結果一樣。而算錯不會 crash,只會永遠回錯的百分位數。
///
/// 這裡塞 20 筆 0.01…0.20:offset = 20*75/100 = 15 → 升冪第 16 筆 = 0.16。
/// 上面那些變異會分別得到 0.01 / 0.01 / 0.20,都跟 0.16 不同。
///
/// 註:`.min(count - 1)` 的 `-` 換成 `+` 是**等價變異**、殺不掉——因為對所有 count >= 1
/// 都有 count*75/100 <= count-1,這個夾制永遠不會生效(它是純防禦性的)。
#[tokio::test]
async fn vitals_stats_p75_picks_the_right_sample() {
let (app, _pool) = test_app().await;
// 故意打亂送出順序:p75 必須靠 SQL 的 ORDER BY,不能依賴插入順序
let mut values: Vec<i32> = (1..=20).collect();
values.rotate_left(7);
for i in values {
let v = f64::from(i) / 100.0;
let (status, _) = post_json(
&app,
"/api/vitals",
json!({ "metric": "CLS", "value": v, "rating": "good", "path": "/blog/1" }),
)
.await;
assert_eq!(status, StatusCode::NO_CONTENT);
}
let (status, body) = get(&app, "/api/vitals/stats").await;
assert_eq!(status, StatusCode::OK);
let cls =
body["metrics"].as_array().unwrap().iter().find(|m| m["metric"] == "CLS").expect("stats 要有 CLS");
assert_eq!(cls["count"], 20);
let p75 = cls["p75"].as_f64().expect("p75 應為數字");
assert!((p75 - 0.16).abs() < 1e-9, "p75 應為 0.16(升冪第 16 筆),實際 {p75}");
// 沒有樣本的 metric:count=0、p75=null,且不能 500
let inp = body["metrics"].as_array().unwrap().iter().find(|m| m["metric"] == "INP").unwrap();
assert_eq!(inp["count"], 0);
assert!(inp["p75"].is_null(), "沒有樣本時 p75 要是 null");
}
/// 極簡 percent-encode(測試用;只處理 query 值需要的字元)
fn urlencode(s: &str) -> String {
let mut out = String::new();
for b in s.bytes() {
match b {
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => out.push(b as char),
_ => {
let _ = write!(out, "%{b:02X}");
}
}
}
out
}