◉ClassyGitshadowzzh

admin.rs

admin.rs
//! 後台 CRUD 的往返測試。
//!
//! ## 為什麼是「往返」而不是逐個端點各測一次
//!
//! admin.rs 有 2298 個 region、覆蓋率 7.57%——是整個後端最大的單一缺口。
//! 但「每個端點打一次、斷言不是 5xx」那種測試只會把數字沖上去,抓不到真正會發生的錯:
//! **建立成功但欄位沒存進去**、**更新回 200 但資料沒變**、**刪除沒連帶清乾淨**。
//! 那三種都會回 2xx,只有回頭再讀一次才看得見。
//!
//! 所以這裡一律「建 → 讀回來比對 → 改 → 再讀回來比對 → 刪 → 確認真的不見了」。
//! 一條往返走過的程式碼比四條淺測試多,而且每一步的斷言都是真的契約。
//!
//! 授權邊界(沒 token → 401)不在這裡重複驗:tests/e2e/api-contract.spec.ts 已經
//! 從 OpenAPI spec 自動列舉所有 bearer 端點做過了,再寫一次只是多一份要維護的東西。

use axum::http::StatusCode;
use serde_json::json;

mod common;
use common::{owner_token, request, test_app};

/// 帶 OWNER token 發請求。後台端點清一色需要它,包一層省得每次都寫。
async fn admin(
    app: &axum::Router,
    method: &str,
    path: &str,
    body: Option<serde_json::Value>,
) -> (StatusCode, serde_json::Value) {
    request(app, method, path, body, Some(&owner_token(true))).await
}

// ── 標籤 ─────────────────────────────────────────────────────────────────

/// 標籤的五語系欄位是最容易「存了但沒讀回來」的地方——它們在 INSERT 與 SELECT
/// 兩份寫死的 SQL 裡各出現一次,改動時很容易只改一邊。
#[tokio::test]
async fn tag_round_trip_keeps_all_locale_fields() {
    let (app, _pool) = test_app().await;

    let (st, created) = admin(
        &app,
        "POST",
        "/api/admin/tags",
        Some(json!({
            "name": "測試標籤", "name_en": "test-tag", "name_ja": "テストタグ",
            "name_ko": "테스트태그", "name_zh_cn": "测试标签"
        })),
    )
    .await;
    assert!(st.is_success(), "建立標籤失敗:{st} {created}");

    let (_, list) = admin(&app, "GET", "/api/admin/tags", None).await;
    let arr = list.as_array().or_else(|| list["tags"].as_array()).expect("標籤清單應該是陣列");
    let mine = arr.iter().find(|t| t["name"] == "測試標籤").expect("剛建立的標籤要出現在清單裡");
    let id = mine["id"].as_i64().expect("標籤要有 id");
    // 五個語系欄位逐一比對——只驗 name 的話,漏存 name_ja 不會有人發現
    for (k, v) in [
        ("name_en", "test-tag"),
        ("name_ja", "テストタグ"),
        ("name_ko", "테스트태그"),
        ("name_zh_cn", "测试标签"),
    ] {
        assert_eq!(mine[k], v, "{k} 沒有存進去(建立時)");
    }

    let (st, _) = admin(
        &app,
        "PUT",
        &format!("/api/admin/tags/{id}"),
        Some(json!({ "name": "改過的標籤", "name_en": "renamed" })),
    )
    .await;
    assert!(st.is_success(), "更新標籤失敗:{st}");

    let (_, list) = admin(&app, "GET", "/api/admin/tags", None).await;
    let arr = list.as_array().or_else(|| list["tags"].as_array()).expect("陣列");
    let after = arr.iter().find(|t| t["id"] == id).expect("更新後標籤還在");
    assert_eq!(after["name"], "改過的標籤", "更新回 2xx 但名稱沒變");
    assert_eq!(after["name_en"], "renamed");
    // 這次沒帶 name_ja → 應該被清成 null(UPDATE 是整列覆寫,不是 patch)
    assert!(after["name_ja"].is_null(), "UPDATE 是整列覆寫,沒帶的欄位該被清掉");

    let (st, _) = admin(&app, "DELETE", &format!("/api/admin/tags/{id}"), None).await;
    assert!(st.is_success(), "刪除標籤失敗:{st}");
    let (_, list) = admin(&app, "GET", "/api/admin/tags", None).await;
    let arr = list.as_array().or_else(|| list["tags"].as_array()).expect("陣列");
    assert!(arr.iter().all(|t| t["id"] != id), "刪除後還在清單裡");
}

/// 刪不存在的標籤要回 404 而不是 200——回 200 會讓前端以為刪掉了。
#[tokio::test]
async fn deleting_a_missing_tag_is_404() {
    let (app, _pool) = test_app().await;
    let (st, _) = admin(&app, "DELETE", "/api/admin/tags/999999", None).await;
    assert_eq!(st, StatusCode::NOT_FOUND);
}

#[tokio::test]
async fn creating_a_tag_without_name_is_400() {
    let (app, _pool) = test_app().await;
    let (st, body) = admin(&app, "POST", "/api/admin/tags", Some(json!({ "name": "" }))).await;
    assert_eq!(st, StatusCode::BAD_REQUEST, "空名稱該被擋下");
    assert!(body["error"].is_string(), "要給得出錯誤訊息:{body}");
}

// ── 分類 ─────────────────────────────────────────────────────────────────

#[tokio::test]
async fn category_round_trip() {
    let (app, _pool) = test_app().await;

    let (st, _) = admin(
        &app,
        "POST",
        "/api/admin/categories",
        Some(json!({ "name": "新分類", "slug": "new-cat", "description": "說明" })),
    )
    .await;
    assert!(st.is_success(), "建立分類失敗:{st}");

    let (_, list) = admin(&app, "GET", "/api/admin/categories", None).await;
    let arr = list.as_array().or_else(|| list["categories"].as_array()).expect("陣列");
    let mine = arr.iter().find(|c| c["name"] == "新分類").expect("新分類要在清單裡");
    assert_eq!(mine["slug"], "new-cat");
    let id = mine["id"].as_i64().expect("id");

    let (st, _) = admin(
        &app,
        "PUT",
        &format!("/api/admin/categories/{id}"),
        Some(json!({ "name": "改名分類", "slug": "renamed-cat" })),
    )
    .await;
    assert!(st.is_success());
    let (_, list) = admin(&app, "GET", "/api/admin/categories", None).await;
    let arr = list.as_array().or_else(|| list["categories"].as_array()).expect("陣列");
    let after = arr.iter().find(|c| c["id"] == id).expect("還在");
    assert_eq!(after["name"], "改名分類");
    assert_eq!(after["slug"], "renamed-cat");
}

// ── IP 黑名單 / 關鍵字過濾 ─────────────────────────────────────────────────

/// 黑名單用 `INSERT OR IGNORE`:重複加同一個 IP 不該爆,也不該變成兩筆。
#[tokio::test]
async fn blacklist_is_idempotent_on_duplicate_ip() {
    let (app, _pool) = test_app().await;
    for _ in 0..2 {
        let (st, _) = admin(
            &app,
            "POST",
            "/api/admin/blacklist",
            Some(json!({ "ip": "203.0.113.7", "reason": "洗版" })),
        )
        .await;
        assert!(st.is_success(), "重複加同一個 IP 不該失敗");
    }
    let (_, list) = admin(&app, "GET", "/api/admin/blacklist", None).await;
    let arr = list.as_array().or_else(|| list["blacklist"].as_array()).expect("陣列");
    let hits: Vec<_> = arr.iter().filter(|b| b["ip"] == "203.0.113.7").collect();
    assert_eq!(hits.len(), 1, "INSERT OR IGNORE 應該只留一筆,實際 {}", hits.len());

    let id = hits[0]["id"].as_i64().expect("id");
    let (st, _) = admin(&app, "DELETE", &format!("/api/admin/blacklist/{id}"), None).await;
    assert!(st.is_success());
}

/// action 只收 spam / reject,其餘一律落回 spam——落回別的值會讓過濾行為變成未定義。
#[tokio::test]
async fn keyword_filter_action_falls_back_to_spam() {
    let (app, _pool) = test_app().await;
    for (keyword, sent, expect) in
        [("賭博", "spam", "spam"), ("代購", "reject", "reject"), ("亂寫", "not-a-real-action", "spam")]
    {
        let (st, _) = admin(
            &app,
            "POST",
            "/api/admin/keyword-filters",
            Some(json!({ "keyword": keyword, "action": sent })),
        )
        .await;
        assert!(st.is_success(), "建立關鍵字 {keyword} 失敗");

        let (_, list) = admin(&app, "GET", "/api/admin/keyword-filters", None).await;
        let arr = list.as_array().or_else(|| list["filters"].as_array()).expect("陣列");
        let mine = arr.iter().find(|f| f["keyword"] == keyword).expect("剛建的要在");
        assert_eq!(mine["action"], expect, "action={sent} 應該落成 {expect}");
    }
}

// ── 留言審核 ─────────────────────────────────────────────────────────────

/// 留言狀態只收四個值。收到不合法的值時若照樣寫進 DB,那條留言會變成
/// 「既不在待審也不在已核准」的幽靈——列表查不到、但它確實存在。
#[tokio::test]
async fn comment_status_rejects_unknown_values() {
    let (app, pool) = test_app().await;
    sqlx::query(
        "INSERT INTO comments (id, post_id, author, content, status) \
         VALUES (500, 1, '讀者', '內容', 'pending')",
    )
    .execute(&pool)
    .await
    .expect("插入留言");

    let (st, _) =
        admin(&app, "PATCH", "/api/admin/comments/500/status", Some(json!({ "status": "banana" }))).await;
    assert_eq!(st, StatusCode::BAD_REQUEST, "不合法的狀態該被擋");

    // 確認真的沒被寫進去
    let after: (String,) =
        sqlx::query_as("SELECT status FROM comments WHERE id = 500").fetch_one(&pool).await.expect("查回來");
    assert_eq!(after.0, "pending", "被拒絕的請求不該留下副作用");

    for s in ["approved", "spam", "trash", "pending"] {
        let (st, _) =
            admin(&app, "PATCH", "/api/admin/comments/500/status", Some(json!({ "status": s }))).await;
        assert!(st.is_success(), "{s} 應該是合法狀態");
        let after: (String,) = sqlx::query_as("SELECT status FROM comments WHERE id = 500")
            .fetch_one(&pool)
            .await
            .expect("查回來");
        assert_eq!(after.0, s, "狀態回 2xx 但沒真的改成 {s}");
    }
}

// ── 統計 ─────────────────────────────────────────────────────────────────

/// admin_stats 整份都是算式。種子資料是「1 篇已發布 + 1 篇草稿」,
/// 所以數字是可以逐一核對的——這種端點錯了不會有任何症狀,只是儀表板數字不對。
#[tokio::test]
async fn admin_stats_counts_match_the_seed() {
    let (app, _pool) = test_app().await;
    let (st, v) = admin(&app, "GET", "/api/admin/stats", None).await;
    assert!(st.is_success(), "stats 失敗:{st} {v}");

    let find = |keys: &[&str]| -> Option<i64> {
        for k in keys {
            if let Some(n) = v[*k].as_i64() {
                return Some(n);
            }
            if let Some(n) = v["stats"][*k].as_i64() {
                return Some(n);
            }
        }
        None
    };
    assert_eq!(find(&["totalPosts", "total_posts"]), Some(2), "種子有 2 篇文章(1 發布 1 草稿):{v}");
    assert_eq!(find(&["publishedPosts", "published"]), Some(1), "已發布應該是 1:{v}");
    assert_eq!(find(&["draftPosts", "draft"]), Some(1), "草稿應該是 1:{v}");
}

// ── 碎念 ─────────────────────────────────────────────────────────────────

/// 碎念的 CRUD。`ref_json` 是那種「存字串、讀出來要是物件」的欄位,
/// 序列化方向錯了前端會拿到一坨轉義過的字串而不是連結卡片。
#[tokio::test]
async fn thought_round_trip_preserves_ref_payload() {
    let (app, _pool) = test_app().await;

    let (st, created) = admin(
        &app,
        "POST",
        "/api/admin/thoughts",
        Some(json!({
            "content": "新碎念",
            "ref_type": "link",
            "ref_url": "https://example.com/a",
            "ref_json": { "title": "範例", "desc": "簡介", "site": "example.com" }
        })),
    )
    .await;
    assert!(st.is_success(), "建立碎念失敗:{st} {created}");

    let (_, list) = admin(&app, "GET", "/api/thoughts", None).await;
    let arr = list["thoughts"].as_array().or_else(|| list.as_array()).expect("碎念清單");
    let mine = arr.iter().find(|t| t["content"] == "新碎念").expect("新碎念要在清單裡");
    let id = mine["id"].as_i64().expect("id");
    // ref 應該是**物件**,不是被轉義的字串
    let r = &mine["ref"];
    if !r.is_null() {
        assert!(r.is_object(), "ref 應該還原成物件,實際是 {r}");
        assert_eq!(r["title"], "範例");
    }

    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/thoughts/{id}"), Some(json!({ "content": "改過的碎念" })))
            .await;
    assert!(st.is_success(), "更新碎念失敗:{st}");

    let (_, one) = admin(&app, "GET", &format!("/api/thoughts/{id}"), None).await;
    let got = if one["thought"].is_object() { &one["thought"] } else { &one };
    assert_eq!(got["content"], "改過的碎念", "更新回 2xx 但內容沒變");

    let (st, _) = admin(&app, "DELETE", &format!("/api/admin/thoughts/{id}"), None).await;
    assert!(st.is_success(), "刪除碎念失敗:{st}");
    let (st, _) = admin(&app, "GET", &format!("/api/thoughts/{id}"), None).await;
    assert_eq!(st, StatusCode::NOT_FOUND, "刪掉之後該查不到");
}

// ── 文章 ─────────────────────────────────────────────────────────────────

/// 文章的往返。這支是後台最大的端點(i18n 欄位 × 5 語系 × title/content/excerpt),
/// 也是最容易「多加一個欄位卻忘了在 UPDATE 那串裡補上」的地方。
#[tokio::test]
async fn post_round_trip_keeps_i18n_and_status() {
    let (app, _pool) = test_app().await;

    let (st, created) = admin(
        &app,
        "POST",
        "/api/admin/posts",
        Some(json!({
            "title": "新文章", "content": "內文", "excerpt": "摘要",
            "category": "技術", "status": "draft",
            "title_en": "New Post", "content_en": "Body", "excerpt_en": "Summary"
        })),
    )
    .await;
    assert!(st.is_success(), "建立文章失敗:{st} {created}");
    // 建立回應把資料包在 `data` 裡(不是 `post`)——三種都試,回應形狀有變的話
    // 這裡會直接指出實際拿到什麼,而不是給一個沒有上下文的 unwrap panic。
    let id = ["data", "post"]
        .iter()
        .find_map(|k| created[*k]["id"].as_i64())
        .or_else(|| created["id"].as_i64())
        .unwrap_or_else(|| panic!("建立回應要帶 id:{created}"));

    let (_, one) = admin(&app, "GET", &format!("/api/admin/posts/{id}"), None).await;
    let got = if one["post"].is_object() { &one["post"] } else { &one };
    assert_eq!(got["title"], "新文章");
    assert_eq!(got["title_en"], "New Post", "英文標題沒存進去");
    assert_eq!(got["status"], "draft");

    // 草稿不該出現在公開清單
    let (_, public) = request(&app, "GET", "/api/posts", None, None).await;
    let titles: Vec<_> =
        public["posts"].as_array().expect("陣列").iter().map(|p| p["title"].clone()).collect();
    assert!(!titles.contains(&json!("新文章")), "草稿漏到公開清單了");

    // 發布之後才該出現
    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "status": "published" }))).await;
    assert!(st.is_success(), "更新文章失敗:{st}");
    let (_, public) = request(&app, "GET", "/api/posts", None, None).await;
    let titles: Vec<_> =
        public["posts"].as_array().expect("陣列").iter().map(|p| p["title"].clone()).collect();
    assert!(titles.contains(&json!("新文章")), "發布後仍沒出現在公開清單:{titles:?}");

    // 刪除先丟回收:後台還查得到、公開清單看不到
    let (st, _) = admin(&app, "DELETE", &format!("/api/admin/posts/{id}"), None).await;
    assert!(st.is_success(), "丟進回收失敗:{st}");
    let (_, one) = admin(&app, "GET", &format!("/api/admin/posts/{id}"), None).await;
    assert_eq!(one["status"], "trashed");
    assert_eq!(one["trashed_from"], "published");
    let (_, public) = request(&app, "GET", "/api/posts", None, None).await;
    let titles: Vec<_> =
        public["posts"].as_array().expect("陣列").iter().map(|p| p["title"].clone()).collect();
    assert!(!titles.contains(&json!("新文章")), "回收裡的文章漏到公開清單了");

    // 從回收永久刪除之後才真的查不到
    let (st, _) = admin(&app, "DELETE", &format!("/api/admin/posts/{id}?permanent=true"), None).await;
    assert!(st.is_success(), "永久刪除失敗:{st}");
    let (st, _) = admin(&app, "GET", &format!("/api/admin/posts/{id}"), None).await;
    assert_eq!(st, StatusCode::NOT_FOUND, "刪掉之後該查不到");
}

// ── 文章更新:三態欄位、slug 歷史、標籤 ──────────────────────────────────
//
// `admin_update_post` 是後台最大的一支(58 行未覆蓋),也是 PostEditor 每次按儲存
// 都會打的那支。它的語意全部是「靜靜地錯」那一類:欄位該清的沒清、不該動的被動了、
// 改了 slug 之後舊網址全部 404。回應一律 200,從外面完全看不出來。

/// 建一篇文章,回它的 id。
async fn create_post(app: &axum::Router, body: serde_json::Value) -> i64 {
    let (st, created) = admin(app, "POST", "/api/admin/posts", Some(body)).await;
    assert!(st.is_success(), "建立文章失敗:{st} {created}");
    ["data", "post"]
        .iter()
        .find_map(|k| created[*k]["id"].as_i64())
        .or_else(|| created["id"].as_i64())
        .unwrap_or_else(|| panic!("建立回應要帶 id:{created}"))
}

async fn get_post(app: &axum::Router, id: i64) -> serde_json::Value {
    let (_, one) = admin(app, "GET", &format!("/api/admin/posts/{id}"), None).await;
    if one["post"].is_object() { one["post"].clone() } else { one }
}

/// **三態**:缺 key → 不動;`""` → 清成 NULL;有值 → 設定。
///
/// 這三種都回 200,差別只在資料庫裡。搞錯的後果很具體:
///   · 「缺 key = 清空」→ PostEditor 只送了改動的欄位,其他語系的譯文全部被抹掉
///   · 「空字串 = 不動」→ 站長想刪掉某個語系的舊譯文,怎麼刪都刪不掉
#[tokio::test]
async fn 更新文章時缺欄位不動_空字串才清空() {
    let (app, _pool) = test_app().await;
    let id = create_post(
        &app,
        json!({
            "title": "原標題", "content": "原內文", "excerpt": "原摘要", "category": "技術",
            "title_en": "EN title", "content_en": "EN body", "excerpt_en": "EN summary",
            "title_ja": "JA タイトル", "content_ja": "JA 本文",
        }),
    )
    .await;

    // 只送 title —— 其餘一律不該被動到
    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "title": "新標題" }))).await;
    assert!(st.is_success());
    let p = get_post(&app, id).await;
    assert_eq!(p["title"], "新標題");
    assert_eq!(p["content"], "原內文", "沒送的欄位被動到了");
    assert_eq!(p["title_en"], "EN title", "沒送的語系欄位被抹掉了——這會吃掉整份譯文");
    assert_eq!(p["title_ja"], "JA タイトル");
    assert_eq!(p["category"], "技術");

    // 空字串 → 真的清成 NULL(站長要刪掉舊譯文的唯一方式)
    let (st, _) = admin(
        &app,
        "PUT",
        &format!("/api/admin/posts/{id}"),
        Some(json!({ "title_en": "", "content_en": "", "excerpt_en": "" })),
    )
    .await;
    assert!(st.is_success());
    let p = get_post(&app, id).await;
    assert!(p["title_en"].is_null(), "空字串應該清成 null,得到 {}", p["title_en"]);
    assert!(p["content_en"].is_null());
    assert_eq!(p["title_ja"], "JA タイトル", "只清 en 不該波及 ja");
    assert_eq!(p["title"], "新標題", "更不該波及主語系");
}

/// 改 slug 要把舊的存進 `post_slug_history`,舊網址才不會斷。
/// 這條壞掉的症狀是:站長改了網址,之前所有分享出去的連結全部 404,
/// 而後台看起來一切正常。
#[tokio::test]
async fn 改_slug_會保留舊網址的轉址() {
    let (app, pool) = test_app().await;
    let id =
        create_post(&app, json!({ "title": "會改網址的文章", "content": "內文", "slug": "old-slug" })).await;
    assert_eq!(get_post(&app, id).await["slug"], "old-slug");

    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "slug": "new-slug" }))).await;
    assert!(st.is_success());
    assert_eq!(get_post(&app, id).await["slug"], "new-slug");

    let history = sqlx::query_scalar::<_, String>("SELECT old_slug FROM post_slug_history WHERE post_id = ?")
        .bind(id)
        .fetch_all(&pool)
        .await
        .unwrap();
    assert_eq!(history, vec!["old-slug"], "舊 slug 沒進 history,之前分享出去的連結會全部 404");

    // 沒帶 slug 的更新不該動到它(也不該多寫一筆歷史)
    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "title": "改標題" }))).await;
    assert!(st.is_success());
    assert_eq!(get_post(&app, id).await["slug"], "new-slug");
    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM post_slug_history WHERE post_id = ?")
        .bind(id)
        .fetch_one(&pool)
        .await
        .unwrap();
    assert_eq!(n, 1, "沒改 slug 卻多了一筆歷史");
}

/// `tags` 帶空陣列=清空關聯,缺 key=不動。兩者都回 200。
#[tokio::test]
async fn 標籤帶空陣列是清空_不帶則不動() {
    let (app, pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "有標籤的文章", "content": "內文", "tags": ["rust"] })).await;
    let count = |pool: sqlx::SqlitePool, id: i64| async move {
        sqlx::query_scalar::<_, i64>("SELECT COUNT(*) FROM post_tags WHERE post_id = ?")
            .bind(id)
            .fetch_one(&pool)
            .await
            .unwrap()
    };
    assert_eq!(count(pool.clone(), id).await, 1, "建立時的標籤沒掛上");

    // 不帶 tags → 關聯不動
    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "title": "改個標題" }))).await;
    assert!(st.is_success());
    assert_eq!(count(pool.clone(), id).await, 1, "沒帶 tags 卻把關聯清掉了");

    // 帶空陣列 → 真的清空
    let (st, _) = admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "tags": [] }))).await;
    assert!(st.is_success());
    assert_eq!(count(pool, id).await, 0, "帶空陣列應該清空關聯");
}

/// 同一個標籤送兩次不該讓儲存失敗。以前第二筆關聯撞 (post_id, tag_id) 主鍵回 500,
/// 而且舊關聯已經先刪掉了——文章的其他標籤就這樣不見。
#[tokio::test]
async fn 重複的標籤只掛一次() {
    let (app, pool) = test_app().await;
    let id =
        create_post(&app, json!({ "title": "文章", "content": "內文", "tags": ["rust", "rust", "web"] }))
            .await;
    let names: Vec<String> = sqlx::query_scalar(
        "SELECT t.name FROM post_tags pt JOIN tags t ON t.id = pt.tag_id WHERE pt.post_id = ? ORDER BY t.name",
    )
    .bind(id)
    .fetch_all(&pool)
    .await
    .unwrap();
    assert_eq!(names, ["rust", "web"]);
}

/// 換標籤中途失敗時,舊標籤要原封不動(整段在 transaction 裡),不能只刪不加。
#[tokio::test]
async fn 換標籤失敗時舊標籤還在() {
    let (app, pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "文章", "content": "內文", "tags": ["rust", "web"] })).await;
    // 讓「boom」這個標籤的關聯一寫就失敗,模擬換到一半出錯
    sqlx::query(
        "CREATE TRIGGER boom BEFORE INSERT ON post_tags \
         WHEN NEW.tag_id = (SELECT id FROM tags WHERE name = 'boom') \
         BEGIN SELECT RAISE(ABORT, 'boom'); END",
    )
    .execute(&pool)
    .await
    .unwrap();

    let (st, _) =
        admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "tags": ["new", "boom"] }))).await;
    assert!(st.is_server_error(), "寫入失敗要回 5xx,得到 {st}");

    let names: Vec<String> = sqlx::query_scalar(
        "SELECT t.name FROM post_tags pt JOIN tags t ON t.id = pt.tag_id WHERE pt.post_id = ? ORDER BY t.name",
    )
    .bind(id)
    .fetch_all(&pool)
    .await
    .unwrap();
    assert_eq!(names, ["rust", "web"], "失敗之後舊標籤被清掉了");
}

/// `source_language` 只接受五個語系。它會決定編輯器把內容寫進哪一組欄位,
/// 收了亂值等於資料寫到不存在的語系去。
#[tokio::test]
async fn 無效的_source_language_會被擋下() {
    let (app, _pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "文章", "content": "內文" })).await;

    for bad in [json!("de"), json!("zh"), json!(""), json!(123), json!(null)] {
        let (st, body) =
            admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "source_language": bad })))
                .await;
        assert_eq!(st, StatusCode::BAD_REQUEST, "source_language={bad} 應該被擋,得到 {body}");
        assert!(body["error"].as_str().unwrap().contains("source_language"));
    }
    for ok in ["zh-TW", "zh-CN", "en", "ja", "ko"] {
        let (st, _) =
            admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "source_language": ok })))
                .await;
        assert!(st.is_success(), "{ok} 應該放行");
    }
}

/// `series_order` 是數字欄位但表單送過來的是字串;三態同其他欄位。
#[tokio::test]
async fn 系列順序接受字串數字_空字串則清空() {
    let (app, _pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "系列文", "content": "內文" })).await;

    let put = |body: serde_json::Value| {
        let app = app.clone();
        async move { admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(body)).await }
    };

    let (st, _) = put(json!({ "series_name": "測試系列", "series_order": "3" })).await;
    assert!(st.is_success());
    let p = get_post(&app, id).await;
    assert_eq!(p["series_name"], "測試系列");
    assert_eq!(p["series_order"], 3, "字串的 \"3\" 要存成數字 3");

    // 空字串 → 清空(站長把文章移出系列)
    let (st, _) = put(json!({ "series_name": "", "series_order": "" })).await;
    assert!(st.is_success());
    let p = get_post(&app, id).await;
    assert!(p["series_name"].is_null(), "得到 {}", p["series_name"]);
    assert!(p["series_order"].is_null());

    // 不是數字的字串不該存成 0(那會讓它排到系列最前面)
    let (st, _) = put(json!({ "series_order": "不是數字" })).await;
    assert!(st.is_success());
    assert!(get_post(&app, id).await["series_order"].is_null(), "解不出數字要留 null,不是 0");
}

/// `allow_comments` 走 JS truthy:表單可能送 boolean、0/1、"true"。
#[tokio::test]
async fn 留言開關照_js_truthy_解讀() {
    let (app, _pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "文章", "content": "內文" })).await;

    // 回應是 typed struct(bool),不是 row_to_json 的 0/1
    for (given, want) in [
        (json!(false), false),
        (json!(true), true),
        (json!(0), false),
        (json!(1), true),
        (json!(""), false),
        (json!("false"), true), // 非空字串在 JS 是 truthy——照抄,不是筆誤
    ] {
        let (st, _) =
            admin(&app, "PUT", &format!("/api/admin/posts/{id}"), Some(json!({ "allow_comments": given })))
                .await;
        assert!(st.is_success());
        assert_eq!(get_post(&app, id).await["allow_comments"], want, "allow_comments={given}");
    }
}

/// 更新不存在的文章要 404,而不是「成功但什麼都沒改」。
#[tokio::test]
async fn 更新不存在的文章是_404() {
    let (app, _pool) = test_app().await;
    let (st, body) =
        admin(&app, "PUT", "/api/admin/posts/999999", Some(json!({ "title": "改一個不存在的" }))).await;
    assert_eq!(st, StatusCode::NOT_FOUND, "得到 {body}");
    assert_eq!(body["error"], "文章不存在");
}

// ── 繁→簡自動轉換(generate-zh-cn)─────────────────────────────────────────
//
// 轉換函式本身(含「日文原樣保留」)在 handlers/opencc.rs 內有單元測試;
// 這裡補的是那支端點的守衛與副作用:轉錯對象、把空摘要寫成空字串、
// 或是轉完沒存回 DB——三種都回 200,只有回頭讀一次才看得見。

#[tokio::test]
async fn 自動轉簡體會把結果寫回文章() {
    let (app, _pool) = test_app().await;
    let id = create_post(
        &app,
        json!({
            "title": "這是繁體標題", "content": "鞋帶鬆了開來", "excerpt": "簡短的摘要",
            "source_language": "zh-TW",
        }),
    )
    .await;

    let (st, v) = admin(&app, "POST", &format!("/api/admin/posts/{id}/generate-zh-cn"), None).await;
    assert!(st.is_success(), "得到 {st} {v}");
    assert_eq!(v["title_zh_cn"], "这是繁体标题");
    assert_eq!(v["content_zh_cn"], "鞋带松了开来");
    assert_eq!(v["excerpt_zh_cn"], "简短的摘要");

    // 回應對了不代表存進去了——回頭讀一次
    let p = get_post(&app, id).await;
    assert_eq!(p["title_zh_cn"], "这是繁体标题", "轉換結果沒寫回 DB");
    assert_eq!(p["content_zh_cn"], "鞋带松了开来");
    assert_eq!(p["excerpt_zh_cn"], "简短的摘要");
    assert_eq!(p["title"], "這是繁體標題", "原文不該被動到");
}

#[tokio::test]
async fn 轉簡體時摘要連結也轉_並回給編輯器() {
    // 編輯器手上那份簡體連結是轉之前的:回應不帶回來的話,下一次存檔會把轉好的蓋掉
    let (app, _pool) = test_app().await;
    let id = create_post(
        &app,
        json!({
            "title": "標題", "content": "## 一\n內文", "excerpt": "先說結論。再講細節。",
            "source_language": "zh-TW",
            "excerpt_links": { "zh-TW": [{ "text": "再講細節。", "to": "01" }] },
        }),
    )
    .await;

    let (st, v) = admin(&app, "POST", &format!("/api/admin/posts/{id}/generate-zh-cn"), None).await;
    assert!(st.is_success(), "得到 {st} {v}");
    assert_eq!(v["excerpt_links_zh_cn"], json!([{ "text": "再讲细节。", "to": "01" }]));
}

#[tokio::test]
async fn 沒有摘要時轉出來的是_null_不是空字串() {
    // 空字串會讓前端的「有沒有簡體版摘要」判斷(truthy)誤判成有,
    // 然後在簡中版顯示一段空白的摘要區塊。
    let (app, _pool) = test_app().await;
    let id = create_post(&app, json!({ "title": "沒有摘要", "content": "內文" })).await;
    let (st, v) = admin(&app, "POST", &format!("/api/admin/posts/{id}/generate-zh-cn"), None).await;
    assert!(st.is_success(), "得到 {v}");
    assert!(v["excerpt_zh_cn"].is_null(), "得到 {}", v["excerpt_zh_cn"]);
}

#[tokio::test]
async fn 只能從_zh_tw_原文轉_其餘一律_400() {
    // 拿日文原文去跑繁簡轉換會把日文漢字改掉——而那是不可逆的(原文已被覆寫)。
    let (app, _pool) = test_app().await;
    for lang in ["ja", "en", "ko", "zh-CN"] {
        let id =
            create_post(&app, json!({ "title": "標題", "content": "內文", "source_language": lang })).await;
        let (st, v) = admin(&app, "POST", &format!("/api/admin/posts/{id}/generate-zh-cn"), None).await;
        assert_eq!(st, StatusCode::BAD_REQUEST, "source_language={lang} 應該被擋,得到 {v}");
    }
}

#[tokio::test]
async fn 原文缺標題或內容時_400_不存在的文章_404() {
    let (app, pool) = test_app().await;
    // 直接插一筆內容為空的(正常路徑建不出來)
    sqlx::query(
        "INSERT INTO posts (id, title, content, status, source_language) VALUES (700, '有標題', '', 'draft', 'zh-TW')",
    )
    .execute(&pool)
    .await
    .unwrap();
    let (st, v) = admin(&app, "POST", "/api/admin/posts/700/generate-zh-cn", None).await;
    assert_eq!(st, StatusCode::BAD_REQUEST, "得到 {v}");

    let (st, v) = admin(&app, "POST", "/api/admin/posts/999999/generate-zh-cn", None).await;
    assert_eq!(st, StatusCode::NOT_FOUND, "得到 {v}");
}