◉ClassyGitshadowzzh

comments.rs

comments.rs
//! 留言的建立(文章與碎念共用同一條路徑)。
//!
//! 原本 54%。沒被走到的正好是**四道守門全部**:captcha、IP 黑名單、關鍵字過濾、
//! 以及「登入的人免審核」。這四道壞掉的樣子都一樣——留言照樣送出、照樣回 201,
//! 差別只在它進了 `comments` 表的哪個 status;沒有 log、沒有告警,
//! 要到有人真的去看後台審核清單才會發現。
//!
//! 這裡刻意連 `status` 欄位一起驗到 DB,不只看回應:回應裡的 status 是另外組出來的
//! 字串,跟真的寫進去的值是兩個東西,只驗前者的話兩邊分岔了也看不出來。

mod common;

use axum::body::Body;
use axum::http::{Request, StatusCode, header};
use common::{TEST_SECRET, get, owner_token, request, test_app};
use http_body_util::BodyExt;
use serde_json::{Value, json};
use tower::ServiceExt;

/// 帶自訂標頭發 POST。common 的 helper 只支援 Bearer,而這裡要驗的是
/// `X-Forwarded-For`(IP 黑名單的唯一輸入)。
async fn post_with(
    app: &axum::Router,
    path: &str,
    body: Value,
    extra: &[(&str, &str)],
) -> (StatusCode, Value) {
    let mut b = Request::builder().method("POST").uri(path).header(header::CONTENT_TYPE, "application/json");
    for (k, v) in extra {
        b = b.header(*k, *v);
    }
    let resp = app.clone().oneshot(b.body(Body::from(body.to_string())).unwrap()).await.unwrap();
    let status = resp.status();
    let bytes = resp.into_body().collect().await.unwrap().to_bytes();
    let v = serde_json::from_slice(&bytes)
        .unwrap_or_else(|_| Value::String(String::from_utf8_lossy(&bytes).into_owned()));
    (status, v)
}

/// OAuth 登入者的 token。判定條件是「同時有 userId 與 provider」——
/// 少任何一個都要被當成匿名,底下有測到。
fn oauth_token(user_id: Option<i64>, provider: Option<&str>) -> String {
    let mut claims = json!({ "username": "someone" });
    if let Some(id) = user_id {
        claims["userId"] = json!(id);
    }
    if let Some(p) = provider {
        claims["provider"] = json!(p);
    }
    let now = koimsurai_web_backend::util::now_secs();
    claims["exp"] = json!(now + 3600);
    jsonwebtoken::encode(
        &jsonwebtoken::Header::default(),
        &claims,
        &jsonwebtoken::EncodingKey::from_secret(TEST_SECRET.as_bytes()),
    )
    .unwrap()
}

async fn status_in_db(pool: &sqlx::SqlitePool, id: i64) -> String {
    sqlx::query_scalar("SELECT status FROM comments WHERE id = ?").bind(id).fetch_one(pool).await.unwrap()
}

#[tokio::test]
async fn 名字或內容缺一不可() {
    let (app, pool) = test_app().await;
    for body in [
        json!({ "content": "只有內容" }),
        json!({ "author": "只有名字" }),
        json!({ "author": "", "content": "" }),
        json!({}),
    ] {
        let (status, resp) = post_with(&app, "/api/posts/1/comments", body.clone(), &[]).await;
        assert_eq!(status, 400, "{body} 應該被拒絕");
        assert_eq!(resp["error"], "Author and content are required");
    }
    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM comments").fetch_one(&pool).await.unwrap();
    assert_eq!(n, 0, "被拒絕的留言不該留下列");
}

#[tokio::test]
async fn 匿名留言預設進待審核() {
    let (app, pool) = test_app().await;
    let (status, resp) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "路人", "content": "寫得好" }), &[]).await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "pending");
    // 預設值若哪天變成 approved,匿名留言就會直接出現在文章底下 —— 沒有人審過
    assert_eq!(status_in_db(&pool, resp["id"].as_i64().unwrap()).await, "pending");
}

#[tokio::test]
async fn 帶了_captcha_就要答對() {
    let (app, _pool) = test_app().await;
    let base = json!({ "author": "路人", "content": "內容" });

    let mut wrong = base.clone();
    wrong["captcha"] = json!(7);
    wrong["captchaAnswer"] = json!(3);
    let (status, resp) = post_with(&app, "/api/posts/1/comments", wrong, &[]).await;
    assert_eq!(status, 400);
    assert_eq!(resp["error"], "驗證碼錯誤");

    let mut right = base.clone();
    right["captcha"] = json!(7);
    right["captchaAnswer"] = json!(7);
    let (status, _) = post_with(&app, "/api/posts/1/comments", right, &[]).await;
    assert_eq!(status, 201);
}

#[tokio::test]
async fn captcha_的字串與數字要當成同一個答案() {
    let (app, _pool) = test_app().await;
    // 前端的答案來自 <input>,一定是字串;題目是數字。嚴格相等會讓**每一個人**
    // 都答不對,而錯誤訊息只會說「驗證碼錯誤」——沒有人猜得到問題出在型別。
    for (q, a) in [(json!(7), json!("7")), (json!("7"), json!(7)), (json!(0), json!(""))] {
        let body = json!({ "author": "路人", "content": "內容", "captcha": q, "captchaAnswer": a });
        let (status, _) = post_with(&app, "/api/posts/1/comments", body, &[]).await;
        assert_eq!(status, 201, "{q} 對 {a} 應該視為相等");
    }
    // 但不能寬鬆到什麼都相等
    let body = json!({ "author": "路人", "content": "內容", "captcha": 7, "captchaAnswer": "七" });
    let (status, _) = post_with(&app, "/api/posts/1/comments", body, &[]).await;
    assert_eq!(status, 400);
}

#[tokio::test]
async fn 沒帶_captcha_欄位就不檢查() {
    let (app, _pool) = test_app().await;
    // captcha 是選配的(站上某些入口沒出題)。缺欄位時若當成「答錯」,那些入口會整個不能留言。
    let (status, _) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "路人", "content": "內容" }), &[]).await;
    assert_eq!(status, 201);
}

#[tokio::test]
async fn 登入的人免審核而且不必答_captcha() {
    let (app, pool) = test_app().await;
    let token = format!("Bearer {}", oauth_token(Some(9), Some("github")));
    let body = json!({
        "author": "登入者", "content": "我是登入的",
        "captcha": 7, "captchaAnswer": 3, // 故意答錯:登入者這一段根本不該跑
    });
    let (status, resp) =
        post_with(&app, "/api/posts/1/comments", body, &[(header::AUTHORIZATION.as_str(), &token)]).await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "approved");
    assert_eq!(status_in_db(&pool, resp["id"].as_i64().unwrap()).await, "approved");
}

#[tokio::test]
async fn 少了_userid_或_provider_的_token_一律當匿名() {
    let (app, _pool) = test_app().await;
    // 免審核是拿 token 換來的,所以「怎樣才算登入」必須嚴格。少一個欄位就放行的話,
    // 任何一顆用同一把密鑰簽出來的 token(例如站內其他用途的)都能繞過審核。
    for (uid, provider, why) in
        [(Some(9), None, "只有 userId"), (None, Some("github"), "只有 provider"), (None, None, "兩個都沒有")]
    {
        let token = format!("Bearer {}", oauth_token(uid, provider));
        let (status, resp) = post_with(
            &app,
            "/api/posts/1/comments",
            json!({ "author": "路人", "content": "內容" }),
            &[(header::AUTHORIZATION.as_str(), &token)],
        )
        .await;
        assert_eq!(status, 201);
        assert_eq!(resp["status"], "pending", "{why} 的 token 不該換到免審核");
    }
}

#[tokio::test]
async fn 簽章不對的_token_不算登入() {
    let (app, _pool) = test_app().await;
    let bogus = jsonwebtoken::encode(
        &jsonwebtoken::Header::default(),
        &json!({ "userId": 9, "provider": "github", "exp": 9_999_999_999i64 }),
        &jsonwebtoken::EncodingKey::from_secret(b"another-secret"),
    )
    .unwrap();
    let (status, resp) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "路人", "content": "內容" }),
        &[(header::AUTHORIZATION.as_str(), &format!("Bearer {bogus}"))],
    )
    .await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "pending", "自己簽的 token 換到了免審核");
}

#[tokio::test]
async fn 黑名單_ip_直接擋掉() {
    let (app, pool) = test_app().await;
    sqlx::query("INSERT INTO ip_blacklist (ip, reason) VALUES ('1.2.3.4', '洗版')")
        .execute(&pool)
        .await
        .unwrap();

    let (status, resp) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "洗版的人", "content": "內容" }),
        &[("x-forwarded-for", "1.2.3.4")],
    )
    .await;
    assert_eq!(status, 403);
    assert_eq!(resp["error"], "您的留言權限已被限制");

    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM comments").fetch_one(&pool).await.unwrap();
    assert_eq!(n, 0, "被封鎖的人不該還是寫得進去");
}

#[tokio::test]
async fn ip_取的是_x_forwarded_for_最左邊那個() {
    let (app, pool) = test_app().await;
    sqlx::query("INSERT INTO ip_blacklist (ip) VALUES ('1.2.3.4')").execute(&pool).await.unwrap();

    // nginx 會把整條鏈都放進 XFF。取錯端(拿最右邊)等於永遠比對到代理的 IP,
    // 黑名單就完全失效——而且失效得很安靜。
    let (status, _) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "洗版的人", "content": "內容" }),
        &[("x-forwarded-for", "1.2.3.4, 10.0.0.1, 172.16.0.1")],
    )
    .await;
    assert_eq!(status, 403, "沒有取到最左邊那個 IP");

    // 前後空白要吃掉(XFF 的分隔慣例是 ", ")
    let (status, _) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "洗版的人", "content": "內容" }),
        &[("x-forwarded-for", "  1.2.3.4  , 10.0.0.1")],
    )
    .await;
    assert_eq!(status, 403, "沒有把 IP 前後的空白去掉");
}

#[tokio::test]
async fn 公開的留言列表不帶留言者的_email_與_ip() {
    let (app, pool) = test_app().await;
    let token = format!("Bearer {}", oauth_token(Some(9), Some("github")));
    // 登入者免審核,送出就是 approved、會出現在公開列表
    let (status, _) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "登入者", "content": "內容", "email": "someone@example.com" }),
        &[(header::AUTHORIZATION.as_str(), &token), ("x-forwarded-for", "5.6.7.8")],
    )
    .await;
    assert_eq!(status, 201);
    sqlx::query(
        "INSERT INTO comments (thought_id, author, content, email, ip, status) VALUES (42, '路人', '內容', 'a@b.c', '9.9.9.9', 'approved')",
    )
    .execute(&pool)
    .await
    .unwrap();
    for path in ["/api/posts/1/comments", "/api/thoughts/42/comments"] {
        let (status, body) = common::get(&app, path).await;
        assert_eq!(status, 200, "{path}");
        let comments = body["comments"].as_array().unwrap();
        assert_eq!(comments.len(), 1, "{path}");
        let row = comments[0].as_object().unwrap();
        // 這兩欄只給後台;公開端點帶出去就是把每個留言者的信箱與位置公開
        assert!(!row.contains_key("email"), "{path} 帶了 email");
        assert!(!row.contains_key("ip"), "{path} 帶了 ip");
        // 整份回應裡也不該出現那兩個值
        let raw = body.to_string();
        assert!(!raw.contains("someone@example.com") && !raw.contains("a@b.c"), "{path}");
        assert!(!raw.contains("5.6.7.8") && !raw.contains("9.9.9.9"), "{path}");
    }
}

#[tokio::test]
async fn 留言會記下來源_ip() {
    let (app, pool) = test_app().await;
    let (_, resp) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "路人", "content": "內容" }),
        &[("x-forwarded-for", "5.6.7.8")],
    )
    .await;
    // 不記 IP 的話「事後把洗版的人加進黑名單」這個流程根本無從下手
    let ip: String = sqlx::query_scalar("SELECT ip FROM comments WHERE id = ?")
        .bind(resp["id"].as_i64().unwrap())
        .fetch_one(&pool)
        .await
        .unwrap();
    assert_eq!(ip, "5.6.7.8");
}

#[tokio::test]
async fn 關鍵字_reject_直接退回_spam_則收下但標記() {
    let (app, pool) = test_app().await;
    for (kw, action) in [("賭博", "reject"), ("代購", "spam")] {
        sqlx::query("INSERT INTO keyword_filters (keyword, action) VALUES (?, ?)")
            .bind(kw)
            .bind(action)
            .execute(&pool)
            .await
            .unwrap();
    }

    let (status, resp) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "甲", "content": "來玩賭博" }), &[]).await;
    assert_eq!(status, 400);
    assert_eq!(resp["error"], "留言內容包含不允許的詞彙");

    // spam 是「收下但不顯示」——直接退回的話洗版的人會知道自己被擋了、換個詞再來
    let (status, resp) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "乙", "content": "代購便宜" }), &[]).await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "spam");
    assert_eq!(status_in_db(&pool, resp["id"].as_i64().unwrap()).await, "spam");
}

#[tokio::test]
async fn 關鍵字比對不分大小寫而且也看名字() {
    let (app, pool) = test_app().await;
    sqlx::query("INSERT INTO keyword_filters (keyword, action) VALUES ('viagra', 'reject')")
        .execute(&pool)
        .await
        .unwrap();

    // 只比對內容、或只比對原樣大小寫的話,這兩種最常見的變形都會漏
    for body in [
        json!({ "author": "路人", "content": "buy VIAGRA now" }),
        json!({ "author": "Viagra 專賣", "content": "正常的內容" }),
    ] {
        let (status, _) = post_with(&app, "/api/posts/1/comments", body.clone(), &[]).await;
        assert_eq!(status, 400, "{body} 應該被關鍵字擋下");
    }
}

#[tokio::test]
async fn 關鍵字_spam_勝過登入者的免審核() {
    let (app, pool) = test_app().await;
    sqlx::query("INSERT INTO keyword_filters (keyword, action) VALUES ('代購', 'spam')")
        .execute(&pool)
        .await
        .unwrap();

    // 免審核不是通行證。登入者發廣告時若因為 is_oauth 就直接 approved,
    // 那條關鍵字規則等於只擋得住沒登入的人。
    let token = format!("Bearer {}", oauth_token(Some(9), Some("github")));
    let (status, resp) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "登入者", "content": "代購便宜" }),
        &[(header::AUTHORIZATION.as_str(), &token)],
    )
    .await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "spam", "登入者的廣告被直接放行了");
}

#[tokio::test]
async fn 沒有關鍵字命中時不受影響() {
    let (app, pool) = test_app().await;
    sqlx::query("INSERT INTO keyword_filters (keyword, action) VALUES ('賭博', 'reject')")
        .execute(&pool)
        .await
        .unwrap();
    let (status, resp) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "路人", "content": "正常留言" }), &[])
            .await;
    assert_eq!(status, 201);
    assert_eq!(resp["status"], "pending");
}

#[tokio::test]
async fn parent_id_是_0_或缺席都存成_null() {
    let (app, pool) = test_app().await;
    for body in [
        json!({ "author": "甲", "content": "頂層留言", "parent_id": 0 }),
        json!({ "author": "乙", "content": "也是頂層" }),
    ] {
        let (_, resp) = post_with(&app, "/api/posts/1/comments", body, &[]).await;
        // 存成 0 的話前端組樹時會去找 id=0 的父留言,整串就掛在一個不存在的節點底下
        let parent: Option<i64> = sqlx::query_scalar("SELECT parent_id FROM comments WHERE id = ?")
            .bind(resp["id"].as_i64().unwrap())
            .fetch_one(&pool)
            .await
            .unwrap();
        assert_eq!(parent, None);
    }
}

#[tokio::test]
async fn 有指定_parent_id_時要留住() {
    let (app, pool) = test_app().await;
    let (_, top) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "甲", "content": "頂層" }), &[]).await;
    let top_id = top["id"].as_i64().unwrap();

    let (_, reply) = post_with(
        &app,
        "/api/posts/1/comments",
        json!({ "author": "乙", "content": "回覆", "parent_id": top_id }),
        &[],
    )
    .await;
    let parent: Option<i64> = sqlx::query_scalar("SELECT parent_id FROM comments WHERE id = ?")
        .bind(reply["id"].as_i64().unwrap())
        .fetch_one(&pool)
        .await
        .unwrap();
    assert_eq!(parent, Some(top_id));
}

#[tokio::test]
async fn 碎念的留言寫進_thought_id_而不是_post_id() {
    let (app, pool) = test_app().await;
    let (status, resp) =
        post_with(&app, "/api/thoughts/1/comments", json!({ "author": "路人", "content": "推" }), &[]).await;
    assert_eq!(status, 201);

    // 兩條路徑共用同一個 create_comment,差別只在傳進去的欄位名。傳錯的話留言會
    // 掛到同編號的**文章**底下 —— 碎念看不到它,而那篇文章底下多一則沒頭沒尾的留言。
    let (post_id, thought_id): (Option<i64>, Option<i64>) =
        sqlx::query_as("SELECT post_id, thought_id FROM comments WHERE id = ?")
            .bind(resp["id"].as_i64().unwrap())
            .fetch_one(&pool)
            .await
            .unwrap();
    assert_eq!(thought_id, Some(1));
    assert_eq!(post_id, None);
}

#[tokio::test]
async fn 選填欄位缺席時存成空字串而不是_null() {
    let (app, pool) = test_app().await;
    let (_, resp) =
        post_with(&app, "/api/posts/1/comments", json!({ "author": "路人", "content": "內容" }), &[]).await;
    // 欄位在 schema 上是 DEFAULT '',回應端也照 '' 處理;存成 NULL 的話後台列表
    // 會出現 null 字樣(而不是空白)
    let (email, website, avatar): (String, String, String) =
        sqlx::query_as("SELECT email, website, avatar_url FROM comments WHERE id = ?")
            .bind(resp["id"].as_i64().unwrap())
            .fetch_one(&pool)
            .await
            .unwrap();
    assert_eq!((email.as_str(), website.as_str(), avatar.as_str()), ("", "", ""));
}

#[tokio::test]
async fn body_不是合法_json_時回_json_錯誤而不是空白() {
    let (app, _pool) = test_app().await;
    let resp = app
        .clone()
        .oneshot(
            Request::builder()
                .method("POST")
                .uri("/api/posts/1/comments")
                .header(header::CONTENT_TYPE, "application/json")
                .body(Body::from("{ 這不是 json"))
                .unwrap(),
        )
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    let bytes = resp.into_body().collect().await.unwrap().to_bytes();
    let v: Value = serde_json::from_slice(&bytes).expect("錯誤回應本身也要是 JSON");
    assert!(v.get("error").is_some(), "沒有 error 欄位:{v}");
}

// ── 留言頁(/messages):不屬於文章也不屬於碎念,記在 comments.page ─────────────
//
// 翻新上線時留言頁送的是 post_id = 'meta-messages',撞 comments.post_id 的外鍵,
// 一則都沒寫進去過(使用者看到的是「送不出去,稍後再試一次」)。

#[tokio::test]
async fn 留言頁的留言寫得進去_審核過才讀得到() {
    let (app, pool) = test_app().await;
    let (status, resp) = post_with(
        &app,
        "/api/pages/messages/comments",
        json!({ "author": "路過", "content": "你好", "captcha": 5, "captchaAnswer": 5 }),
        &[],
    )
    .await;
    assert_eq!(status, 201, "{resp}");
    let id = resp["id"].as_i64().unwrap();
    assert_eq!(status_in_db(&pool, id).await, "pending", "匿名的一樣要審核");
    let (page, post): (Option<String>, Option<i64>) =
        sqlx::query_as("SELECT page, post_id FROM comments WHERE id = ?")
            .bind(id)
            .fetch_one(&pool)
            .await
            .unwrap();
    assert_eq!(page.as_deref(), Some("messages"));
    assert_eq!(post, None, "不該掛在任何一篇文章上");

    let (_, list) = get(&app, "/api/pages/messages/comments").await;
    assert_eq!(list["comments"].as_array().unwrap().len(), 0, "待審核的不公開");
    sqlx::query("UPDATE comments SET status = 'approved' WHERE id = ?")
        .bind(id)
        .execute(&pool)
        .await
        .unwrap();
    let (_, list) = get(&app, "/api/pages/messages/comments").await;
    assert_eq!(list["comments"][0]["content"], "你好");
}

#[tokio::test]
async fn 登入的留言在留言頁直接公開() {
    let (app, _pool) = test_app().await;
    let token = format!("Bearer {}", oauth_token(Some(9), Some("github")));
    let (status, resp) = post_with(
        &app,
        "/api/pages/messages/comments",
        json!({ "author": "某人", "content": "嗨" }),
        &[(header::AUTHORIZATION.as_str(), &token)],
    )
    .await;
    assert_eq!(status, 201, "{resp}");
    let (_, list) = get(&app, "/api/pages/messages/comments").await;
    assert_eq!(list["comments"][0]["author"], "某人");
}

#[tokio::test]
async fn 不在白名單的頁面沒有留言區() {
    let (app, pool) = test_app().await;
    let (status, _) = get(&app, "/api/pages/anything/comments").await;
    assert_eq!(status, 404);
    let (status, _) =
        post_with(&app, "/api/pages/anything/comments", json!({ "author": "a", "content": "b" }), &[]).await;
    assert_eq!(status, 404);
    let n: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM comments").fetch_one(&pool).await.unwrap();
    assert_eq!(n, 0);
}

#[tokio::test]
async fn 站長回覆留言頁或碎念的留言_回覆留在同一個地方() {
    // 以前只抄原留言的 post_id:回覆碎念或留言頁的留言時,回覆變成哪裡都不屬於的孤兒
    let (app, pool) = test_app().await;
    let token = owner_token(true);
    sqlx::query("INSERT INTO comments (id, page, author, content, status) VALUES (900, 'messages', '訪客', '問題', 'approved')")
        .execute(&pool)
        .await
        .unwrap();
    sqlx::query("INSERT INTO comments (id, thought_id, author, content, status) VALUES (901, 7, '訪客', '碎念留言', 'approved')")
        .execute(&pool)
        .await
        .unwrap();
    for (parent, want_page, want_thought) in [(900, Some("messages"), None), (901, None, Some(7))] {
        let (status, resp) = request(
            &app,
            "POST",
            &format!("/api/admin/comments/{parent}/reply"),
            Some(json!({ "content": "回覆" })),
            Some(&token),
        )
        .await;
        assert_eq!(status, 201, "{resp}");
        let (page, thought): (Option<String>, Option<i64>) =
            sqlx::query_as("SELECT page, thought_id FROM comments WHERE id = ?")
                .bind(resp["id"].as_i64().unwrap())
                .fetch_one(&pool)
                .await
                .unwrap();
        assert_eq!(page.as_deref(), want_page, "回覆 #{parent}");
        assert_eq!(thought, want_thought, "回覆 #{parent}");
    }
}