Mangalord/backend/tests/api_chapters.rs

mod common;

use axum::http::StatusCode;
use serde_json::json;
use sqlx::PgPool;
use tower::ServiceExt;
use uuid::Uuid;
#[allow(unused_imports)]
use serde_json as _;

async fn seed_manga(h: &common::Harness, cookie: &str, title: &str) -> Uuid {
    common::seed_manga_via_api(&h.app, cookie, title).await
}

async fn seed_chapter(
    pool: &PgPool,
    manga_id: Uuid,
    number: i32,
    title: Option<&str>,
) -> Uuid {
    // Historical seed — uploaded_by remains NULL, mirroring the
    // pre-Phase-5 rows in the production DB.
    mangalord::repo::chapter::create(pool, manga_id, number, title, None)
        .await
        .unwrap()
        .id
}

#[sqlx::test(migrations = "./migrations")]
async fn list_chapters_is_empty_initially(pool: PgPool) {
    let h = common::harness(pool);
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;

    let resp = h
        .app
        .oneshot(common::get(&format!("/api/v1/mangas/{manga_id}/chapters")))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let body = common::body_json(resp).await;
    assert_eq!(body["items"], json!([]));
    assert_eq!(body["page"]["limit"], 50);
    assert_eq!(body["page"]["offset"], 0);
    assert!(body["page"]["total"].is_null());
}

#[sqlx::test(migrations = "./migrations")]
async fn list_chapters_returned_in_number_order(pool: PgPool) {
    let h = common::harness(pool.clone());
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;

    seed_chapter(&pool, manga_id, 3, Some("The Black Swordsman")).await;
    seed_chapter(&pool, manga_id, 1, Some("The Brand")).await;
    seed_chapter(&pool, manga_id, 2, None).await;

    let resp = h
        .app
        .oneshot(common::get(&format!("/api/v1/mangas/{manga_id}/chapters")))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let body = common::body_json(resp).await;
    let numbers: Vec<i64> = body["items"]
        .as_array()
        .unwrap()
        .iter()
        .map(|c| c["number"].as_i64().unwrap())
        .collect();
    assert_eq!(numbers, vec![1, 2, 3]);
    assert_eq!(body["items"][1]["title"], serde_json::Value::Null);
}

#[sqlx::test(migrations = "./migrations")]
async fn list_chapters_returns_404_for_unknown_manga(pool: PgPool) {
    let h = common::harness(pool);
    let unknown = Uuid::nil();
    let resp = h
        .app
        .oneshot(common::get(&format!("/api/v1/mangas/{unknown}/chapters")))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
    let body = common::body_json(resp).await;
    assert_eq!(body["error"]["code"], "not_found");
}

#[sqlx::test(migrations = "./migrations")]
async fn get_chapter_by_id(pool: PgPool) {
    let h = common::harness(pool.clone());
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;
    let chapter_id = seed_chapter(&pool, manga_id, 1, Some("The Brand")).await;

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/{chapter_id}"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let body = common::body_json(resp).await;
    assert_eq!(body["number"], 1);
    assert_eq!(body["title"], "The Brand");
    assert_eq!(body["page_count"], 0);
    assert_eq!(body["id"], chapter_id.to_string());
}

#[sqlx::test(migrations = "./migrations")]
async fn get_chapter_unknown_id_is_404(pool: PgPool) {
    let h = common::harness(pool);
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;
    let unknown_chapter = Uuid::new_v4();

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/{unknown_chapter}"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
    let body = common::body_json(resp).await;
    assert_eq!(body["error"]["code"], "not_found");
}

#[sqlx::test(migrations = "./migrations")]
async fn get_chapter_unknown_manga_is_404(pool: PgPool) {
    let h = common::harness(pool);
    let unknown_manga = Uuid::nil();
    let unknown_chapter = Uuid::new_v4();
    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{unknown_manga}/chapters/{unknown_chapter}"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}

/// Cross-manga isolation: a chapter id belonging to manga A must not
/// resolve when accessed via manga B's URL. The (manga_id, id) scoping
/// in `find_by_id_in_manga` enforces this.
#[sqlx::test(migrations = "./migrations")]
async fn get_chapter_from_wrong_manga_is_404(pool: PgPool) {
    let h = common::harness(pool.clone());
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_a = seed_manga(&h, &cookie, "Berserk").await;
    let manga_b = seed_manga(&h, &cookie, "Vagabond").await;
    let chapter_id = seed_chapter(&pool, manga_a, 1, Some("Episode 1")).await;

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_b}/chapters/{chapter_id}"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}

#[sqlx::test(migrations = "./migrations")]
async fn list_pages_empty_for_chapter_without_upload(pool: PgPool) {
    let h = common::harness(pool.clone());
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;
    let chapter_id = seed_chapter(&pool, manga_id, 1, None).await;

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/{chapter_id}/pages"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::OK);
    let body = common::body_json(resp).await;
    assert_eq!(body["pages"], json!([]));
}

#[sqlx::test(migrations = "./migrations")]
async fn list_pages_returns_404_for_unknown_chapter(pool: PgPool) {
    let h = common::harness(pool);
    let (_, cookie) = common::register_user(&h.app).await;
    let manga_id = seed_manga(&h, &cookie, "Berserk").await;
    let unknown_chapter = Uuid::new_v4();

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/{unknown_chapter}/pages"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}