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>) {
    mangalord::repo::chapter::create(pool, manga_id, number, title)
        .await
        .unwrap();
}

#[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_number(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, 1, Some("The Brand")).await;

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/1"
        )))
        .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);
}

#[sqlx::test(migrations = "./migrations")]
async fn get_chapter_unknown_number_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 resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/99"
        )))
        .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 = Uuid::nil();
    let resp = h
        .app
        .oneshot(common::get(&format!("/api/v1/mangas/{unknown}/chapters/1")))
        .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;
    seed_chapter(&pool, manga_id, 1, None).await;

    let resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/1/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 resp = h
        .app
        .oneshot(common::get(&format!(
            "/api/v1/mangas/{manga_id}/chapters/99/pages"
        )))
        .await
        .unwrap();
    assert_eq!(resp.status(), StatusCode::NOT_FOUND);
}