54cbbfc440
Three 0.87.9 follow-ups: 1. hooks.server.ts: two new tests covering the already-aborted-at-entry and mid-flight client-disconnect branches of the abort chain. Mutation-confirmed. 2. lib/api/admin.ts: two new tests pinning the getAnalysisMangaCoverage(init?.signal) pass-through and the AbortError-rejection propagation the dashboard's debounce-race handler relies on. Mutation-confirmed. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
1004 lines
38 KiB
TypeScript
1004 lines
38 KiB
TypeScript
import {
|
|
describe,
|
|
it,
|
|
expect,
|
|
vi,
|
|
beforeEach,
|
|
afterEach,
|
|
type MockInstance
|
|
} from 'vitest';
|
|
import {
|
|
listAdminUsers,
|
|
deleteAdminUser,
|
|
setUserAdmin,
|
|
createAdminUser,
|
|
listAdminMangas,
|
|
listAdminChapters,
|
|
getSystemStats,
|
|
getOverviewStats,
|
|
getStorageStats,
|
|
backfillStorage,
|
|
resyncManga,
|
|
resyncChapter,
|
|
getCrawlerStatus,
|
|
crawlerStatusStreamUrl,
|
|
runCrawlerPass,
|
|
reconcileCrawler,
|
|
restartCrawlerBrowser,
|
|
updateCrawlerSession,
|
|
clearCrawlerSessionExpired,
|
|
listDeadJobs,
|
|
requeueDeadJobs,
|
|
listActiveJobs,
|
|
listMissingCovers,
|
|
reenqueueAnalysis,
|
|
analyzePage,
|
|
getAnalysisMangaCoverage,
|
|
getAnalysisChapterCoverage,
|
|
getAnalysisChapterPages,
|
|
getAnalysisPageDetail,
|
|
analysisStatusStreamUrl,
|
|
listCrawlerJobHistory,
|
|
listAnalysisHistory,
|
|
getCrawlerMetrics,
|
|
listCrawlerOps,
|
|
getAnalysisMetrics,
|
|
listAuditLog,
|
|
getHealth,
|
|
updateHealthThresholds,
|
|
getCrawlerMetricsSeries,
|
|
getAnalysisMetricsSeries
|
|
} from './admin';
|
|
|
|
function ok(body: unknown, status = 200): Response {
|
|
return new Response(JSON.stringify(body), {
|
|
status,
|
|
headers: { 'content-type': 'application/json' }
|
|
});
|
|
}
|
|
|
|
function noContent(): Response {
|
|
return new Response(null, { status: 204 });
|
|
}
|
|
|
|
function envelope(status: number, code: string, message: string): Response {
|
|
return new Response(JSON.stringify({ error: { code, message } }), {
|
|
status,
|
|
headers: { 'content-type': 'application/json' }
|
|
});
|
|
}
|
|
|
|
const userFixture = {
|
|
id: 'u-1',
|
|
username: 'alice',
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
is_admin: false
|
|
};
|
|
|
|
const mangaFixture = {
|
|
id: 'm-1',
|
|
title: 'Test',
|
|
status: 'ongoing',
|
|
cover_image_path: null,
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
updated_at: '2026-01-01T00:00:00Z',
|
|
sync_state: 'synced' as const,
|
|
chapter_count: 3,
|
|
latest_seen_at: '2026-01-02T00:00:00Z'
|
|
};
|
|
|
|
const systemFixture = {
|
|
disk: {
|
|
total_bytes: 1_000_000,
|
|
used_bytes: 500_000,
|
|
free_bytes: 500_000,
|
|
percent_used: 50.0
|
|
},
|
|
memory: { total_bytes: 8_000_000, used_bytes: 4_000_000, percent_used: 50.0 },
|
|
cpu: {
|
|
percent_used: 12.3,
|
|
load_avg: { one: 0.81, five: 0.66, fifteen: 0.59 },
|
|
per_core: [10.0, 14.5, 8.2, 20.1]
|
|
},
|
|
temperatures: [
|
|
{ label: 'CPU Package', celsius: 52.0, max_celsius: 71.0, critical_celsius: 100.0 }
|
|
],
|
|
alerts: []
|
|
};
|
|
|
|
describe('admin api client', () => {
|
|
let fetchSpy: MockInstance<typeof globalThis.fetch>;
|
|
|
|
beforeEach(() => {
|
|
fetchSpy = vi.spyOn(globalThis, 'fetch');
|
|
});
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
// ---- users ----
|
|
|
|
it('listAdminUsers GETs /v1/admin/users and parses the paged envelope', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [userFixture], page: { limit: 50, offset: 0, total: 1 } })
|
|
);
|
|
const page = await listAdminUsers({ limit: 50 });
|
|
expect(page.items).toHaveLength(1);
|
|
expect(page.items[0]).toEqual(userFixture);
|
|
expect(page.page.total).toBe(1);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/users\?limit=50$/);
|
|
});
|
|
|
|
it('listAdminUsers forwards search + offset query params', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 50, offset: 10, total: 0 } })
|
|
);
|
|
await listAdminUsers({ search: 'al', offset: 10 });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('search=al');
|
|
expect(url).toContain('offset=10');
|
|
});
|
|
|
|
it('listAdminUsers surfaces 403 forbidden via ApiError.code', async () => {
|
|
fetchSpy.mockResolvedValueOnce(envelope(403, 'forbidden', 'forbidden'));
|
|
await expect(listAdminUsers()).rejects.toMatchObject({
|
|
status: 403,
|
|
code: 'forbidden'
|
|
});
|
|
});
|
|
|
|
it('deleteAdminUser DELETEs to /v1/admin/users/{id} and handles 204', async () => {
|
|
fetchSpy.mockResolvedValueOnce(noContent());
|
|
await expect(deleteAdminUser('u-1')).resolves.toBeUndefined();
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/users\/u-1$/);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('DELETE');
|
|
});
|
|
|
|
it('deleteAdminUser surfaces 409 conflict (self-delete / last-admin)', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
envelope(409, 'conflict', 'cannot delete yourself; ask another admin')
|
|
);
|
|
await expect(deleteAdminUser('u-1')).rejects.toMatchObject({
|
|
status: 409,
|
|
code: 'conflict'
|
|
});
|
|
});
|
|
|
|
it('createAdminUser POSTs to /v1/admin/users with body and returns the created user', async () => {
|
|
const created = { ...userFixture, username: 'invited01' };
|
|
fetchSpy.mockResolvedValueOnce(ok(created, 201));
|
|
const got = await createAdminUser({
|
|
username: 'invited01',
|
|
password: 'freshpass1234'
|
|
});
|
|
expect(got).toEqual(created);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/users$/);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
expect(JSON.parse(init.body as string)).toEqual({
|
|
username: 'invited01',
|
|
password: 'freshpass1234'
|
|
});
|
|
});
|
|
|
|
it('createAdminUser forwards is_admin when provided', async () => {
|
|
const created = { ...userFixture, username: 'coadmin', is_admin: true };
|
|
fetchSpy.mockResolvedValueOnce(ok(created, 201));
|
|
await createAdminUser({
|
|
username: 'coadmin',
|
|
password: 'freshpass1234',
|
|
is_admin: true
|
|
});
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(JSON.parse(init.body as string)).toEqual({
|
|
username: 'coadmin',
|
|
password: 'freshpass1234',
|
|
is_admin: true
|
|
});
|
|
});
|
|
|
|
it('createAdminUser surfaces 409 conflict on duplicate username', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
envelope(409, 'conflict', 'username is already taken')
|
|
);
|
|
await expect(
|
|
createAdminUser({ username: 'taken', password: 'freshpass1234' })
|
|
).rejects.toMatchObject({ status: 409, code: 'conflict' });
|
|
});
|
|
|
|
it('setUserAdmin PATCHes is_admin and returns the updated user', async () => {
|
|
const updated = { ...userFixture, is_admin: true };
|
|
fetchSpy.mockResolvedValueOnce(ok(updated));
|
|
const got = await setUserAdmin('u-1', true);
|
|
expect(got).toEqual(updated);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('PATCH');
|
|
expect(JSON.parse(init.body as string)).toEqual({ is_admin: true });
|
|
});
|
|
|
|
// ---- mangas + chapters ----
|
|
|
|
it('listAdminMangas GETs /v1/admin/mangas and forwards sync_state filter', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [mangaFixture], page: { limit: 100, offset: 0, total: 1 } })
|
|
);
|
|
const page = await listAdminMangas({ syncState: 'in_progress', limit: 100 });
|
|
expect(page.items[0].sync_state).toBe('synced');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('sync_state=in_progress');
|
|
expect(url).toContain('limit=100');
|
|
});
|
|
|
|
it('listAdminChapters GETs the nested chapter route and parses the paged envelope', async () => {
|
|
const chapter = {
|
|
id: 'c-1',
|
|
manga_id: 'm-1',
|
|
number: 1,
|
|
title: null,
|
|
page_count: 12,
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
sync_state: 'synced' as const,
|
|
latest_seen_at: null
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [chapter], page: { limit: 200, offset: 0, total: 1 } })
|
|
);
|
|
const resp = await listAdminChapters('m-1');
|
|
expect(resp.items).toEqual([chapter]);
|
|
expect(resp.page.total).toBe(1);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/mangas\/m-1\/chapters$/);
|
|
});
|
|
|
|
it('listAdminChapters forwards limit + offset query params', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 50, offset: 100, total: 0 } })
|
|
);
|
|
await listAdminChapters('m-1', { limit: 50, offset: 100 });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('limit=50');
|
|
expect(url).toContain('offset=100');
|
|
});
|
|
|
|
// ---- system ----
|
|
|
|
it('getSystemStats GETs /v1/admin/system and parses the four-key envelope', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok(systemFixture));
|
|
const s = await getSystemStats();
|
|
expect(s.disk?.percent_used).toBe(50);
|
|
expect(s.memory.percent_used).toBe(50);
|
|
expect(s.cpu.percent_used).toBe(12.3);
|
|
expect(s.cpu.load_avg.one).toBe(0.81);
|
|
expect(s.cpu.per_core).toHaveLength(4);
|
|
expect(s.temperatures[0].label).toBe('CPU Package');
|
|
expect(s.temperatures[0].critical_celsius).toBe(100);
|
|
expect(s.alerts).toEqual([]);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/system$/);
|
|
});
|
|
|
|
it('getSystemStats keeps disk null when backend reports a non-local store', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ ...systemFixture, disk: null }));
|
|
const s = await getSystemStats();
|
|
expect(s.disk).toBeNull();
|
|
});
|
|
|
|
it('getSystemStats tolerates an empty temperatures array (sensors unavailable)', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ ...systemFixture, temperatures: [] }));
|
|
const s = await getSystemStats();
|
|
expect(s.temperatures).toEqual([]);
|
|
});
|
|
|
|
it('getOverviewStats GETs /v1/admin/overview and parses the nested envelope', async () => {
|
|
const fixture = {
|
|
users: {
|
|
total: 7,
|
|
admins: 2,
|
|
newest_username: 'kenji',
|
|
newest_created_at: '2026-06-15T00:00:00Z'
|
|
},
|
|
mangas: {
|
|
total: 12,
|
|
synced: 10,
|
|
in_progress: 1,
|
|
dropped: 1,
|
|
total_chapters: 340,
|
|
total_pages: 9001,
|
|
newest_title: 'Sakamoto Days',
|
|
newest_seen_at: '2026-06-16T00:00:00Z'
|
|
},
|
|
analysis: { analyzed_pages: 5760, total_pages: 9001 }
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(ok(fixture));
|
|
const s = await getOverviewStats();
|
|
expect(s.users.total).toBe(7);
|
|
expect(s.users.admins).toBe(2);
|
|
expect(s.mangas.synced).toBe(10);
|
|
expect(s.mangas.total_pages).toBe(9001);
|
|
expect(s.analysis.analyzed_pages).toBe(5760);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/overview$/);
|
|
});
|
|
|
|
// ---- force resync ----
|
|
|
|
it('resyncManga POSTs to /v1/admin/mangas/{id}/resync and returns the envelope', async () => {
|
|
const resp = {
|
|
manga: {
|
|
id: 'm-1',
|
|
title: 'T',
|
|
status: 'ongoing',
|
|
alt_titles: [],
|
|
description: null,
|
|
cover_image_path: 'mangas/m-1/cover.jpg',
|
|
created_at: '2026-01-01T00:00:00Z',
|
|
updated_at: '2026-01-02T00:00:00Z',
|
|
authors: [],
|
|
genres: [],
|
|
tags: []
|
|
},
|
|
metadata_status: 'updated',
|
|
cover_fetched: true
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(ok(resp));
|
|
const got = await resyncManga('m-1');
|
|
expect(got.metadata_status).toBe('updated');
|
|
expect(got.cover_fetched).toBe(true);
|
|
expect(got.manga.id).toBe('m-1');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/mangas\/m-1\/resync$/);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
});
|
|
|
|
it('resyncManga surfaces 503 service_unavailable when the daemon is off', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
envelope(503, 'service_unavailable', 'crawler daemon is disabled')
|
|
);
|
|
await expect(resyncManga('m-1')).rejects.toMatchObject({
|
|
status: 503,
|
|
code: 'service_unavailable'
|
|
});
|
|
});
|
|
|
|
it('resyncChapter POSTs to /v1/admin/chapters/{id}/resync and returns the envelope', async () => {
|
|
const resp = {
|
|
chapter: {
|
|
id: 'c-1',
|
|
manga_id: 'm-1',
|
|
number: 1,
|
|
title: 'Foo',
|
|
page_count: 7,
|
|
created_at: '2026-01-01T00:00:00Z'
|
|
},
|
|
outcome: 'fetched',
|
|
pages: 7
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(ok(resp));
|
|
const got = await resyncChapter('c-1');
|
|
expect(got.outcome).toBe('fetched');
|
|
expect(got.pages).toBe(7);
|
|
expect(got.chapter.page_count).toBe(7);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/chapters\/c-1\/resync$/);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
});
|
|
|
|
it('resyncChapter handles the "skipped" outcome envelope', async () => {
|
|
const resp = {
|
|
chapter: {
|
|
id: 'c-1',
|
|
manga_id: 'm-1',
|
|
number: 1,
|
|
title: null,
|
|
page_count: 7,
|
|
created_at: '2026-01-01T00:00:00Z'
|
|
},
|
|
outcome: 'skipped',
|
|
pages: null
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(ok(resp));
|
|
const got = await resyncChapter('c-1');
|
|
expect(got.outcome).toBe('skipped');
|
|
expect(got.pages).toBeNull();
|
|
});
|
|
});
|
|
|
|
describe('admin crawler api client', () => {
|
|
let fetchSpy: MockInstance<typeof globalThis.fetch>;
|
|
beforeEach(() => {
|
|
fetchSpy = vi.spyOn(globalThis, 'fetch');
|
|
});
|
|
afterEach(() => {
|
|
vi.restoreAllMocks();
|
|
});
|
|
|
|
const statusFixture = {
|
|
daemon: 'running',
|
|
phase: { state: 'fetching_metadata', index: 3, total: 10, title: 'One Piece' },
|
|
worker_count: 2,
|
|
active_chapters: [
|
|
{
|
|
manga_id: 'm-1',
|
|
manga_title: 'Bleach',
|
|
chapter_id: 'c-1',
|
|
chapter_number: 12,
|
|
pages_done: 4,
|
|
pages_total: 20
|
|
}
|
|
],
|
|
current_cover: { manga_id: 'm-2', manga_title: 'Naruto' },
|
|
covers_queued: 7,
|
|
last_pass: { at: null, discovered: 0, upserted: 0, covers_fetched: 0, mangas_failed: 0 },
|
|
session: { expired: false, configured: true },
|
|
browser: 'healthy',
|
|
queue: { pending: 2, running: 1, dead: 4 }
|
|
};
|
|
|
|
it('crawlerStatusStreamUrl points at the SSE endpoint under the API base', () => {
|
|
expect(crawlerStatusStreamUrl()).toMatch(/\/v1\/admin\/crawler\/stream$/);
|
|
});
|
|
|
|
it('getCrawlerStatus GETs /v1/admin/crawler with live chapter/cover fields', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok(statusFixture));
|
|
const s = await getCrawlerStatus();
|
|
expect(s.queue.dead).toBe(4);
|
|
expect(s.phase?.state).toBe('fetching_metadata');
|
|
expect(s.active_chapters[0].pages_done).toBe(4);
|
|
expect(s.active_chapters[0].pages_total).toBe(20);
|
|
expect(s.current_cover?.manga_title).toBe('Naruto');
|
|
expect(s.covers_queued).toBe(7);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/crawler$/);
|
|
});
|
|
|
|
it('listActiveJobs GETs /v1/admin/crawler/active-jobs with search', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 20, offset: 0, total: 0 } })
|
|
);
|
|
await listActiveJobs({ search: 'bleach' });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/crawler\/active-jobs\?/);
|
|
expect(url).toContain('search=bleach');
|
|
});
|
|
|
|
it('listMissingCovers GETs /v1/admin/crawler/covers', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [{ manga_id: 'm-1', manga_title: 'X' }], page: { limit: 20, offset: 0, total: 1 } })
|
|
);
|
|
const r = await listMissingCovers();
|
|
expect(r.items[0].manga_title).toBe('X');
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/crawler\/covers$/);
|
|
});
|
|
|
|
it('listAuditLog GETs /v1/admin/audit with the paged envelope', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({
|
|
items: [
|
|
{
|
|
id: 'a-1',
|
|
actor_user_id: 'u-1',
|
|
actor_username: 'alice',
|
|
action: 'crawler_run',
|
|
target_kind: 'crawler',
|
|
target_id: null,
|
|
payload: {},
|
|
at: '2026-06-01T00:00:00Z'
|
|
}
|
|
],
|
|
page: { limit: 25, offset: 0, total: 1 }
|
|
})
|
|
);
|
|
const r = await listAuditLog({ limit: 25 });
|
|
expect(r.items[0].action).toBe('crawler_run');
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/audit\?limit=25$/);
|
|
});
|
|
|
|
it('listAuditLog forwards action / target_kind / days filters', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 25, offset: 0, total: 0 } })
|
|
);
|
|
await listAuditLog({ action: 'manga_resync', targetKind: 'manga', days: 7 });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('action=manga_resync');
|
|
expect(url).toContain('target_kind=manga');
|
|
expect(url).toContain('days=7');
|
|
});
|
|
|
|
const healthFixture = {
|
|
status: 'ok' as const,
|
|
checks: [
|
|
{
|
|
id: 'memory',
|
|
label: 'Memory usage',
|
|
status: 'ok' as const,
|
|
value: '48%',
|
|
threshold: '90%',
|
|
hint: null,
|
|
action_href: null
|
|
}
|
|
],
|
|
thresholds: {
|
|
disk_pct: 90,
|
|
mem_pct: 90,
|
|
dead_jobs_max: 100,
|
|
crawl_fail_pct: 20,
|
|
analysis_fail_pct: 20,
|
|
cron_freshness_hours: 26,
|
|
missing_covers_max: 500
|
|
}
|
|
};
|
|
|
|
it('getCrawlerMetricsSeries GETs the crawler series with days', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ buckets: [] }));
|
|
await getCrawlerMetricsSeries(7);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/crawler\/metrics\/series\?days=7$/);
|
|
});
|
|
|
|
it('getAnalysisMetricsSeries omits days=0 (all-time)', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ buckets: [] }));
|
|
await getAnalysisMetricsSeries(0);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/analysis\/metrics\/series$/);
|
|
});
|
|
|
|
it('getHealth GETs /v1/admin/health', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok(healthFixture));
|
|
const r = await getHealth();
|
|
expect(r.status).toBe('ok');
|
|
expect(r.checks[0].id).toBe('memory');
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/health$/);
|
|
});
|
|
|
|
it('updateHealthThresholds PUTs the thresholds body', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok(healthFixture));
|
|
await updateHealthThresholds(healthFixture.thresholds);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/health\/thresholds$/);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('PUT');
|
|
expect(JSON.parse(init.body as string).dead_jobs_max).toBe(100);
|
|
});
|
|
|
|
it('runCrawlerPass POSTs /v1/admin/crawler/run', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ started: true }));
|
|
const r = await runCrawlerPass();
|
|
expect(r.started).toBe(true);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/crawler\/run$/);
|
|
});
|
|
|
|
it('reconcileCrawler POSTs /v1/admin/crawler/reconcile', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ started: true }));
|
|
const r = await reconcileCrawler();
|
|
expect(r.started).toBe(true);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/crawler\/reconcile$/);
|
|
});
|
|
|
|
it('restartCrawlerBrowser POSTs the restart endpoint', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ ok: true, error: null }));
|
|
const r = await restartCrawlerBrowser();
|
|
expect(r.ok).toBe(true);
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/crawler\/browser\/restart$/);
|
|
});
|
|
|
|
it('updateCrawlerSession POSTs the phpsessid body', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ valid: true, error: null }));
|
|
const r = await updateCrawlerSession('abc123');
|
|
expect(r.valid).toBe(true);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.method).toBe('POST');
|
|
expect(JSON.parse(init.body as string)).toEqual({ phpsessid: 'abc123' });
|
|
});
|
|
|
|
it('clearCrawlerSessionExpired POSTs clear-expired', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ cleared: true }));
|
|
const r = await clearCrawlerSessionExpired();
|
|
expect(r.cleared).toBe(true);
|
|
expect(fetchSpy.mock.calls[0][0]).toMatch(/\/v1\/admin\/crawler\/session\/clear-expired$/);
|
|
});
|
|
|
|
it('listDeadJobs forwards search + pagination', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 20, offset: 20, total: 0 } })
|
|
);
|
|
await listDeadJobs({ search: 'naruto', limit: 20, offset: 20 });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('search=naruto');
|
|
expect(url).toContain('offset=20');
|
|
});
|
|
|
|
it('requeueDeadJobs POSTs the scope body', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ requeued: 3 }));
|
|
const r = await requeueDeadJobs({ scope: 'manga', manga_id: 'm-9' });
|
|
expect(r.requeued).toBe(3);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(JSON.parse(init.body as string)).toEqual({ scope: 'manga', manga_id: 'm-9' });
|
|
});
|
|
|
|
it('requeueDeadJobs serialises chapter scope verbatim', async () => {
|
|
// F7 — the per-chapter requeue button in /admin/mangas sends this
|
|
// exact shape; pin it so a future rename of `chapter_id` doesn't
|
|
// silently break the inline button.
|
|
fetchSpy.mockResolvedValueOnce(ok({ requeued: 1 }));
|
|
const r = await requeueDeadJobs({ scope: 'chapter', chapter_id: 'c-7' });
|
|
expect(r.requeued).toBe(1);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(JSON.parse(init.body as string)).toEqual({
|
|
scope: 'chapter',
|
|
chapter_id: 'c-7'
|
|
});
|
|
});
|
|
|
|
it('requeueDeadJobs serialises job + all (with confirm) scopes', async () => {
|
|
// Round out the variant coverage: { scope: 'job', job_id } and
|
|
// { scope: 'all', confirm: true }. The audit (S1) requires the
|
|
// confirm flag on the wire for scope=all; this pins it so a
|
|
// future refactor can't drop it.
|
|
fetchSpy.mockResolvedValueOnce(ok({ requeued: 1 }));
|
|
await requeueDeadJobs({ scope: 'job', job_id: 'j-1' });
|
|
expect(JSON.parse(fetchSpy.mock.calls[0][1]!.body as string)).toEqual({
|
|
scope: 'job',
|
|
job_id: 'j-1'
|
|
});
|
|
fetchSpy.mockResolvedValueOnce(ok({ requeued: 99 }));
|
|
await requeueDeadJobs({ scope: 'all', confirm: true });
|
|
expect(JSON.parse(fetchSpy.mock.calls[1][1]!.body as string)).toEqual({
|
|
scope: 'all',
|
|
confirm: true
|
|
});
|
|
});
|
|
|
|
it('surfaces a 503 as ApiError', async () => {
|
|
fetchSpy.mockResolvedValueOnce(envelope(503, 'service_unavailable', 'disabled'));
|
|
await expect(runCrawlerPass()).rejects.toMatchObject({ status: 503 });
|
|
});
|
|
|
|
it('reenqueueAnalysis defaults to whole-library, exclude-analyzed', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ enqueued: 42 }));
|
|
const r = await reenqueueAnalysis();
|
|
expect(r.enqueued).toBe(42);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/analysis\/reenqueue$/);
|
|
expect(JSON.parse(fetchSpy.mock.calls[0][1]!.body as string)).toEqual({
|
|
only_unanalyzed: true
|
|
});
|
|
});
|
|
|
|
it('reenqueueAnalysis scopes to a manga and can include analyzed', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ enqueued: 7 }));
|
|
await reenqueueAnalysis({ mangaId: 'm1', onlyUnanalyzed: false });
|
|
expect(JSON.parse(fetchSpy.mock.calls[0][1]!.body as string)).toEqual({
|
|
only_unanalyzed: false,
|
|
manga_id: 'm1'
|
|
});
|
|
});
|
|
|
|
it('reenqueueAnalysis scopes to a chapter', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ enqueued: 3 }));
|
|
await reenqueueAnalysis({ chapterId: 'c1' });
|
|
expect(JSON.parse(fetchSpy.mock.calls[0][1]!.body as string)).toEqual({
|
|
only_unanalyzed: true,
|
|
chapter_id: 'c1'
|
|
});
|
|
});
|
|
|
|
it('analyzePage posts to the force-analyze endpoint', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ enqueued: true }));
|
|
const r = await analyzePage('p1');
|
|
expect(r.enqueued).toBe(true);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/pages\/p1\/analyze$/);
|
|
expect(fetchSpy.mock.calls[0][1]!.method).toBe('POST');
|
|
});
|
|
|
|
it('getAnalysisMangaCoverage passes search + pagination', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 25, offset: 0, total: 0 } })
|
|
);
|
|
await getAnalysisMangaCoverage({ search: 'ber', limit: 25, offset: 50 });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('/v1/admin/analysis/mangas?');
|
|
expect(url).toContain('search=ber');
|
|
expect(url).toContain('limit=25');
|
|
expect(url).toContain('offset=50');
|
|
});
|
|
|
|
it('getAnalysisMangaCoverage forwards the AbortSignal to fetch', async () => {
|
|
// The dashboard's debounce-race fix (0.87.9) relies on this knob
|
|
// landing on `init.signal`. Without it, a slow first request
|
|
// can still overwrite a faster second one because `request()`
|
|
// builds a fresh fetch with no cancellation hook.
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 50, offset: 0, total: 0 } })
|
|
);
|
|
const ctrl = new AbortController();
|
|
await getAnalysisMangaCoverage(
|
|
{ limit: 50 },
|
|
{ signal: ctrl.signal }
|
|
);
|
|
const init = fetchSpy.mock.calls[0][1] as RequestInit;
|
|
expect(init.signal).toBe(ctrl.signal);
|
|
});
|
|
|
|
it('getAnalysisMangaCoverage propagates an abort rejection', async () => {
|
|
// Mid-flight abort: caller flips the AbortController, the fetch
|
|
// promise rejects, and the api client lets the rejection
|
|
// surface to its caller (the debounce-race handler treats
|
|
// AbortError as silent cancellation rather than an error toast).
|
|
const ctrl = new AbortController();
|
|
fetchSpy.mockImplementationOnce(
|
|
(_url, init) =>
|
|
new Promise((_resolve, reject) => {
|
|
const signal = (init as RequestInit).signal;
|
|
signal?.addEventListener(
|
|
'abort',
|
|
() => reject(new DOMException('aborted', 'AbortError')),
|
|
{ once: true }
|
|
);
|
|
})
|
|
);
|
|
const inflight = getAnalysisMangaCoverage(
|
|
{ limit: 25 },
|
|
{ signal: ctrl.signal }
|
|
);
|
|
ctrl.abort();
|
|
await expect(inflight).rejects.toMatchObject({ name: 'AbortError' });
|
|
});
|
|
|
|
it('getAnalysisChapterCoverage unwraps items', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [{ chapter_id: 'c1', number: 1, title: null, total_pages: 2, analyzed_pages: 1 }] })
|
|
);
|
|
const items = await getAnalysisChapterCoverage('m1');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/analysis\/mangas\/m1\/chapters$/);
|
|
expect(items).toHaveLength(1);
|
|
});
|
|
|
|
it('getAnalysisChapterPages unwraps items', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [{ page_id: 'p1', page_number: 1, status: 'done' }] })
|
|
);
|
|
const items = await getAnalysisChapterPages('c1');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/analysis\/chapters\/c1\/pages$/);
|
|
expect(items[0].status).toBe('done');
|
|
});
|
|
|
|
it('getAnalysisPageDetail hits the page endpoint', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ page_id: 'p1', status: 'none', ocr: [], tags: [], content_warnings: [] })
|
|
);
|
|
const d = await getAnalysisPageDetail('p1');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/analysis\/pages\/p1$/);
|
|
expect(d.status).toBe('none');
|
|
});
|
|
|
|
it('analysisStatusStreamUrl points at the SSE endpoint', () => {
|
|
expect(analysisStatusStreamUrl()).toMatch(
|
|
/\/v1\/admin\/analysis\/status\/stream$/
|
|
);
|
|
});
|
|
|
|
// ---- storage usage ----
|
|
|
|
it('getStorageStats GETs /v1/admin/storage and parses the envelope', async () => {
|
|
const fixture = {
|
|
total_bytes: 700,
|
|
covers_bytes: 100,
|
|
chapters_bytes: 600,
|
|
disk_total_bytes: 1_000_000,
|
|
ratio_of_disk: 0.0007,
|
|
avg_image_bytes: 233.3,
|
|
avg_cover_bytes: 100,
|
|
avg_chapter_page_bytes: 300,
|
|
top_mangas: [{ id: 'm-1', title: 'Big', total_bytes: 650 }],
|
|
top_chapters: [
|
|
{ id: 'c-1', manga_id: 'm-1', number: 1, title: null, total_bytes: 600 }
|
|
],
|
|
unmeasured_pages: 4,
|
|
unmeasured_covers: 1
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(ok(fixture));
|
|
const s = await getStorageStats();
|
|
expect(s.total_bytes).toBe(700);
|
|
expect(s.top_mangas[0].title).toBe('Big');
|
|
expect(s.top_chapters[0].total_bytes).toBe(600);
|
|
expect(s.unmeasured_pages).toBe(4);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/storage$/);
|
|
});
|
|
|
|
it('getStorageStats keeps disk total + ratio null for a non-local store', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({
|
|
total_bytes: 0,
|
|
covers_bytes: 0,
|
|
chapters_bytes: 0,
|
|
disk_total_bytes: null,
|
|
ratio_of_disk: null,
|
|
avg_image_bytes: null,
|
|
avg_cover_bytes: null,
|
|
avg_chapter_page_bytes: null,
|
|
top_mangas: [],
|
|
top_chapters: [],
|
|
unmeasured_pages: 0,
|
|
unmeasured_covers: 0
|
|
})
|
|
);
|
|
const s = await getStorageStats();
|
|
expect(s.disk_total_bytes).toBeNull();
|
|
expect(s.ratio_of_disk).toBeNull();
|
|
});
|
|
|
|
it('backfillStorage POSTs /v1/admin/storage/backfill and returns counts', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ pages: 3, covers: 1, missing: 0, errored: 0, more_remaining: false })
|
|
);
|
|
const r = await backfillStorage();
|
|
expect(r).toEqual({ pages: 3, covers: 1, missing: 0, errored: 0, more_remaining: false });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/storage\/backfill$/);
|
|
expect(fetchSpy.mock.calls[0][1]!.method).toBe('POST');
|
|
});
|
|
|
|
// ---- job history ----
|
|
|
|
it('listCrawlerJobHistory forwards state/kind/search/limit/offset and parses items', async () => {
|
|
const row = {
|
|
id: 'j-1',
|
|
state: 'done',
|
|
kind: 'analyze_page',
|
|
manga_id: 'm-1',
|
|
manga_title: 'Berserk',
|
|
chapter_id: 'c-1',
|
|
chapter_number: 12,
|
|
page_number: 7,
|
|
source_key: null,
|
|
attempts: 1,
|
|
max_attempts: 5,
|
|
last_error: null,
|
|
updated_at: '2026-06-15T00:00:00Z'
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [row], page: { limit: 50, offset: 0, total: 1 } })
|
|
);
|
|
const page = await listCrawlerJobHistory({
|
|
state: 'done',
|
|
kind: 'analyze_page',
|
|
search: 'Ber',
|
|
offset: 10
|
|
});
|
|
expect(page.items[0]).toEqual(row);
|
|
expect(page.page.total).toBe(1);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('/v1/admin/crawler/history?');
|
|
expect(url).toContain('state=done');
|
|
expect(url).toContain('kind=analyze_page');
|
|
expect(url).toContain('search=Ber');
|
|
expect(url).toContain('offset=10');
|
|
});
|
|
|
|
it('listCrawlerJobHistory omits unset filters', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 50, offset: 0, total: 0 } })
|
|
);
|
|
await listCrawlerJobHistory();
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/crawler\/history$/);
|
|
});
|
|
|
|
it('listAnalysisHistory forwards status/nsfw/search and parses items', async () => {
|
|
const row = {
|
|
page_id: 'p-1',
|
|
page_number: 3,
|
|
chapter_id: 'c-1',
|
|
chapter_number: 700,
|
|
manga_id: 'm-1',
|
|
manga_title: 'Naruto',
|
|
status: 'failed',
|
|
is_nsfw: false,
|
|
model: null,
|
|
error: 'boom',
|
|
analyzed_at: '2026-06-15T00:00:00Z'
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [row], page: { limit: 25, offset: 0, total: 1 } })
|
|
);
|
|
const page = await listAnalysisHistory({ status: 'failed', nsfw: true, search: 'Nar' });
|
|
expect(page.items[0]).toEqual(row);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('/v1/admin/analysis/history?');
|
|
expect(url).toContain('status=failed');
|
|
expect(url).toContain('nsfw=true');
|
|
expect(url).toContain('search=Nar');
|
|
});
|
|
|
|
it('listAnalysisHistory omits nsfw when false', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [], page: { limit: 25, offset: 0, total: 0 } })
|
|
);
|
|
await listAnalysisHistory({ status: 'done', nsfw: false });
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('status=done');
|
|
expect(url).not.toContain('nsfw');
|
|
});
|
|
|
|
// ---- operation metrics ----
|
|
|
|
it('getCrawlerMetrics omits days when 0 and parses the summary', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({
|
|
summary: [
|
|
{ op: 'chapter', avg_ms: 7000, n: 2, ok: 1, failed: 1, avg_items: 15 }
|
|
]
|
|
})
|
|
);
|
|
const r = await getCrawlerMetrics(0);
|
|
expect(r.summary[0].avg_ms).toBe(7000);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toMatch(/\/v1\/admin\/crawler\/metrics$/);
|
|
});
|
|
|
|
it('getCrawlerMetrics forwards a positive days window', async () => {
|
|
fetchSpy.mockResolvedValueOnce(ok({ summary: [] }));
|
|
await getCrawlerMetrics(7);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('days=7');
|
|
});
|
|
|
|
it('listCrawlerOps forwards op/outcome/days and parses the page', async () => {
|
|
const row = {
|
|
id: 'o-1',
|
|
op: 'chapter',
|
|
manga_id: 'm-1',
|
|
manga_title: 'Berserk',
|
|
chapter_id: 'c-1',
|
|
chapter_number: 12,
|
|
outcome: 'ok',
|
|
duration_ms: 6100,
|
|
items: 20,
|
|
error: null,
|
|
finished_at: '2026-06-15T00:00:00Z'
|
|
};
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({ items: [row], page: { limit: 50, offset: 0, total: 1 } })
|
|
);
|
|
const page = await listCrawlerOps({ op: 'chapter', outcome: 'ok', days: 30 });
|
|
expect(page.items[0]).toEqual(row);
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('/v1/admin/crawler/metrics/ops?');
|
|
expect(url).toContain('op=chapter');
|
|
expect(url).toContain('outcome=ok');
|
|
expect(url).toContain('days=30');
|
|
});
|
|
|
|
it('getAnalysisMetrics parses aggregate + by-model', async () => {
|
|
fetchSpy.mockResolvedValueOnce(
|
|
ok({
|
|
n: 4,
|
|
ok: 3,
|
|
failed: 1,
|
|
avg_ms: 2500,
|
|
by_model: [{ model: 'qwen', avg_ms: 3000, n: 2 }]
|
|
})
|
|
);
|
|
const m = await getAnalysisMetrics(7);
|
|
expect(m.avg_ms).toBe(2500);
|
|
expect(m.by_model[0].model).toBe('qwen');
|
|
const url = fetchSpy.mock.calls[0][0] as string;
|
|
expect(url).toContain('/v1/admin/analysis/metrics?days=7');
|
|
});
|
|
});
|