aa2159ca06
- admin_safe_set_is_admin: short-circuit when target.is_admin == value,
before writing audit. PATCH {is_admin: true} on someone already admin
previously wrote a misleading "promote_user" row even though the UPDATE
was a no-op.
- list_chapters (/admin/mangas/:id/chapters): explicit exists() check on
manga_id, returns 404 instead of 200 [] for a typo'd / deleted manga.
- ChapterSyncState priority: the Failed branch now requires page_count = 0,
so a chapter with pages on disk AND a historical dead job (from a
re-download attempt that crashed) stays Synced. The old order
contradicted Synced's documented "downloaded at some point" contract.
Doc comments updated alongside the SQL.
Three new regression tests pin the behaviour.
487 lines
15 KiB
Rust
487 lines
15 KiB
Rust
//! PR 3 (feat/admin-mangas-api) integration tests.
|
|
//!
|
|
//! Per-variant fixture tests for the derived sync-state SQL plus
|
|
//! happy-path E2E for the two admin endpoints. Auth-gate regression
|
|
//! (403/401) is covered by PR 1's `RequireAdmin` test matrix; the only
|
|
//! gate test here is one spot check per endpoint.
|
|
|
|
mod common;
|
|
|
|
use axum::http::StatusCode;
|
|
use axum::Router;
|
|
use serde_json::json;
|
|
use sqlx::PgPool;
|
|
use tower::ServiceExt;
|
|
use uuid::Uuid;
|
|
|
|
use mangalord::repo;
|
|
|
|
const SOURCE_ID: &str = "test-source";
|
|
|
|
async fn seed_admin(pool: &PgPool, app: &Router) -> (String, String) {
|
|
let (username, cookie) = common::register_user(app).await;
|
|
let u = repo::user::find_by_username(pool, &username)
|
|
.await
|
|
.unwrap()
|
|
.unwrap();
|
|
repo::user::set_is_admin(pool, u.id, true).await.unwrap();
|
|
(username, cookie)
|
|
}
|
|
|
|
async fn seed_source(pool: &PgPool) {
|
|
repo::crawler::ensure_source(pool, SOURCE_ID, "Test", "https://example.test")
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
async fn insert_manga(pool: &PgPool, title: &str) -> Uuid {
|
|
let (id,): (Uuid,) = sqlx::query_as(
|
|
"INSERT INTO mangas (title, status, alt_titles) VALUES ($1, 'ongoing', ARRAY[]::text[]) RETURNING id",
|
|
)
|
|
.bind(title)
|
|
.fetch_one(pool)
|
|
.await
|
|
.unwrap();
|
|
id
|
|
}
|
|
|
|
async fn insert_manga_source(
|
|
pool: &PgPool,
|
|
manga_id: Uuid,
|
|
source_manga_key: &str,
|
|
dropped: bool,
|
|
) {
|
|
let dropped_at = if dropped { "now()" } else { "NULL" };
|
|
let sql = format!(
|
|
"INSERT INTO manga_sources (source_id, source_manga_key, manga_id, source_url, dropped_at) \
|
|
VALUES ($1, $2, $3, 'https://example.test/m', {dropped_at})"
|
|
);
|
|
sqlx::query(&sql)
|
|
.bind(SOURCE_ID)
|
|
.bind(source_manga_key)
|
|
.bind(manga_id)
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
async fn insert_chapter(pool: &PgPool, manga_id: Uuid, number: i32, page_count: i32) -> Uuid {
|
|
let (id,): (Uuid,) = sqlx::query_as(
|
|
"INSERT INTO chapters (manga_id, number, title, page_count) VALUES ($1, $2, NULL, $3) RETURNING id",
|
|
)
|
|
.bind(manga_id)
|
|
.bind(number)
|
|
.bind(page_count)
|
|
.fetch_one(pool)
|
|
.await
|
|
.unwrap();
|
|
id
|
|
}
|
|
|
|
async fn insert_chapter_source(
|
|
pool: &PgPool,
|
|
chapter_id: Uuid,
|
|
source_chapter_key: &str,
|
|
dropped: bool,
|
|
) {
|
|
let dropped_at = if dropped { "now()" } else { "NULL" };
|
|
let sql = format!(
|
|
"INSERT INTO chapter_sources (source_id, source_chapter_key, chapter_id, source_url, dropped_at) \
|
|
VALUES ($1, $2, $3, 'https://example.test/c', {dropped_at})"
|
|
);
|
|
sqlx::query(&sql)
|
|
.bind(SOURCE_ID)
|
|
.bind(source_chapter_key)
|
|
.bind(chapter_id)
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
async fn insert_job(pool: &PgPool, payload: serde_json::Value, state: &str) {
|
|
sqlx::query("INSERT INTO crawler_jobs (payload, state) VALUES ($1, $2)")
|
|
.bind(payload)
|
|
.bind(state)
|
|
.execute(pool)
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
// ---- manga sync state ------------------------------------------------------
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_state_synced_for_fresh_source(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "Synced Manga").await;
|
|
insert_manga_source(&pool, m, "smk-1", false).await;
|
|
|
|
let (rows, total) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(total, 1);
|
|
assert_eq!(rows[0].id, m);
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::MangaSyncState::Synced);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_state_synced_for_user_upload_without_sources(pool: PgPool) {
|
|
let m = insert_manga(&pool, "User Upload").await;
|
|
let (rows, _) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows[0].id, m);
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::MangaSyncState::Synced);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_state_dropped_when_all_sources_dropped(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "Dropped Manga").await;
|
|
insert_manga_source(&pool, m, "smk-1", true).await;
|
|
|
|
let (rows, _) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows[0].id, m);
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::MangaSyncState::Dropped);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_state_in_progress_via_sync_chapter_list_job(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "Syncing Manga").await;
|
|
insert_manga_source(&pool, m, "smk-1", false).await;
|
|
// sync_chapter_list payload carries manga_id directly.
|
|
insert_job(
|
|
&pool,
|
|
json!({
|
|
"kind": "sync_chapter_list",
|
|
"source_id": SOURCE_ID,
|
|
"manga_id": m.to_string(),
|
|
"source_manga_key": "smk-1",
|
|
}),
|
|
"pending",
|
|
)
|
|
.await;
|
|
|
|
let (rows, _) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::MangaSyncState::InProgress);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_state_in_progress_via_sync_manga_job(pool: PgPool) {
|
|
// The trickier branch: sync_manga payload is keyed by
|
|
// source_manga_key, NOT manga_id — must join through manga_sources.
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "Metadata-Refreshing Manga").await;
|
|
insert_manga_source(&pool, m, "smk-key-42", false).await;
|
|
insert_job(
|
|
&pool,
|
|
json!({
|
|
"kind": "sync_manga",
|
|
"source_id": SOURCE_ID,
|
|
"source_manga_key": "smk-key-42",
|
|
}),
|
|
"running",
|
|
)
|
|
.await;
|
|
|
|
let (rows, _) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::MangaSyncState::InProgress);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn manga_list_filters_by_sync_state(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m_synced = insert_manga(&pool, "AAA Synced").await;
|
|
insert_manga_source(&pool, m_synced, "smk-a", false).await;
|
|
let m_dropped = insert_manga(&pool, "BBB Dropped").await;
|
|
insert_manga_source(&pool, m_dropped, "smk-b", true).await;
|
|
|
|
let (rows, total) = repo::admin_view::list_mangas_with_sync_state(
|
|
&pool,
|
|
&repo::admin_view::ListAdminMangasQuery {
|
|
sync_state: Some(mangalord::domain::MangaSyncState::Dropped),
|
|
limit: 50,
|
|
..Default::default()
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(total, 1);
|
|
assert_eq!(rows.len(), 1);
|
|
assert_eq!(rows[0].id, m_dropped);
|
|
}
|
|
|
|
// ---- chapter sync state ----------------------------------------------------
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_synced_when_pages_present(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
insert_manga_source(&pool, m, "smk", false).await;
|
|
let c = insert_chapter(&pool, m, 1, 12).await;
|
|
insert_chapter_source(&pool, c, "ckey-1", false).await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(rows.len(), 1);
|
|
assert_eq!(rows[0].id, c);
|
|
assert_eq!(rows[0].sync_state, mangalord::domain::ChapterSyncState::Synced);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_not_downloaded_when_page_count_zero(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c = insert_chapter(&pool, m, 1, 0).await;
|
|
insert_chapter_source(&pool, c, "ckey-1", false).await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
rows[0].sync_state,
|
|
mangalord::domain::ChapterSyncState::NotDownloaded
|
|
);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_downloading_when_job_in_flight(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c = insert_chapter(&pool, m, 1, 0).await;
|
|
insert_chapter_source(&pool, c, "ckey-1", false).await;
|
|
insert_job(
|
|
&pool,
|
|
json!({
|
|
"kind": "sync_chapter_content",
|
|
"source_id": SOURCE_ID,
|
|
"chapter_id": c.to_string(),
|
|
"source_chapter_key": "ckey-1",
|
|
}),
|
|
"running",
|
|
)
|
|
.await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
rows[0].sync_state,
|
|
mangalord::domain::ChapterSyncState::Downloading
|
|
);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_dropped_when_all_sources_dropped(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c = insert_chapter(&pool, m, 1, 0).await;
|
|
insert_chapter_source(&pool, c, "ckey-1", true).await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
rows[0].sync_state,
|
|
mangalord::domain::ChapterSyncState::Dropped
|
|
);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_failed_when_most_recent_job_dead(pool: PgPool) {
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c = insert_chapter(&pool, m, 1, 0).await;
|
|
insert_chapter_source(&pool, c, "ckey-1", false).await;
|
|
insert_job(
|
|
&pool,
|
|
json!({
|
|
"kind": "sync_chapter_content",
|
|
"source_id": SOURCE_ID,
|
|
"chapter_id": c.to_string(),
|
|
"source_chapter_key": "ckey-1",
|
|
}),
|
|
"dead",
|
|
)
|
|
.await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
rows[0].sync_state,
|
|
mangalord::domain::ChapterSyncState::Failed
|
|
);
|
|
}
|
|
|
|
// ---- HTTP-level happy-path + gate ------------------------------------------
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn http_list_mangas_returns_paged_with_state(pool: PgPool) {
|
|
let h = common::harness(pool.clone());
|
|
let (_admin, cookie) = seed_admin(&pool, &h.app).await;
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "Hello").await;
|
|
insert_manga_source(&pool, m, "smk", false).await;
|
|
|
|
let resp = h
|
|
.app
|
|
.oneshot(common::get_with_cookie(
|
|
"/api/v1/admin/mangas?limit=50",
|
|
&cookie,
|
|
))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status(), StatusCode::OK);
|
|
let body = common::body_json(resp).await;
|
|
let items = body["items"].as_array().unwrap();
|
|
assert_eq!(items.len(), 1);
|
|
assert_eq!(items[0]["id"], m.to_string());
|
|
assert_eq!(items[0]["sync_state"], "synced");
|
|
assert_eq!(items[0]["chapter_count"], 0);
|
|
assert_eq!(body["page"]["total"], 1);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn http_list_mangas_rejects_unknown_sync_state(pool: PgPool) {
|
|
let h = common::harness(pool.clone());
|
|
let (_admin, cookie) = seed_admin(&pool, &h.app).await;
|
|
let resp = h
|
|
.app
|
|
.oneshot(common::get_with_cookie(
|
|
"/api/v1/admin/mangas?sync_state=bogus",
|
|
&cookie,
|
|
))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn http_list_chapters_returns_per_chapter_state(pool: PgPool) {
|
|
let h = common::harness(pool.clone());
|
|
let (_admin, cookie) = seed_admin(&pool, &h.app).await;
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c1 = insert_chapter(&pool, m, 1, 12).await;
|
|
let c2 = insert_chapter(&pool, m, 2, 0).await;
|
|
insert_chapter_source(&pool, c1, "ck1", false).await;
|
|
insert_chapter_source(&pool, c2, "ck2", false).await;
|
|
|
|
let resp = h
|
|
.app
|
|
.oneshot(common::get_with_cookie(
|
|
&format!("/api/v1/admin/mangas/{m}/chapters"),
|
|
&cookie,
|
|
))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status(), StatusCode::OK);
|
|
let body = common::body_json(resp).await;
|
|
let items = body.as_array().unwrap();
|
|
assert_eq!(items.len(), 2);
|
|
assert_eq!(items[0]["id"], c1.to_string());
|
|
assert_eq!(items[0]["sync_state"], "synced");
|
|
assert_eq!(items[1]["id"], c2.to_string());
|
|
assert_eq!(items[1]["sync_state"], "not_downloaded");
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn http_list_chapters_returns_404_for_unknown_manga(pool: PgPool) {
|
|
// Regression: used to return 200 [] for a non-existent manga,
|
|
// which silently rendered "No chapters." for a typo'd / deleted id.
|
|
let h = common::harness(pool.clone());
|
|
let (_admin, cookie) = seed_admin(&pool, &h.app).await;
|
|
let resp = h
|
|
.app
|
|
.oneshot(common::get_with_cookie(
|
|
&format!("/api/v1/admin/mangas/{}/chapters", Uuid::new_v4()),
|
|
&cookie,
|
|
))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status(), StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn chapter_state_synced_when_pages_present_even_with_dead_job(pool: PgPool) {
|
|
// Regression: the old CASE prioritised the dead-job branch above
|
|
// the page_count check, so a chapter with pages on disk AND a
|
|
// historical dead job (e.g. from a re-download attempt that
|
|
// crashed) flipped to Failed — contradicting Synced's "downloaded
|
|
// at some point" contract.
|
|
seed_source(&pool).await;
|
|
let m = insert_manga(&pool, "M").await;
|
|
let c = insert_chapter(&pool, m, 1, 12).await; // pages present
|
|
insert_chapter_source(&pool, c, "ckey-1", false).await;
|
|
insert_job(
|
|
&pool,
|
|
json!({
|
|
"kind": "sync_chapter_content",
|
|
"source_id": SOURCE_ID,
|
|
"chapter_id": c.to_string(),
|
|
"source_chapter_key": "ckey-1",
|
|
}),
|
|
"dead",
|
|
)
|
|
.await;
|
|
|
|
let rows = repo::admin_view::list_chapters_with_sync_state(&pool, m)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(
|
|
rows[0].sync_state,
|
|
mangalord::domain::ChapterSyncState::Synced,
|
|
"pages on disk override historical dead-job noise"
|
|
);
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn http_list_mangas_requires_admin(pool: PgPool) {
|
|
let h = common::harness(pool);
|
|
let (_u, cookie) = common::register_user(&h.app).await;
|
|
let resp = h
|
|
.app
|
|
.oneshot(common::get_with_cookie("/api/v1/admin/mangas", &cookie))
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(resp.status(), StatusCode::FORBIDDEN);
|
|
}
|