Peach: Local-first video metadata scraper and media manager.
/* 人工复核页的行为:分类是地址栏上的身份,分组筛选分页是这一刻的看法,判定只改缓存里
* 那几行,以及只读数据库上这一页什么都不写。
*
* 外观(卡片底色、页签选中态)是设计决定,由 `frontend/e2e/design-*.test.ts` 读
* `getComputedStyle` 断言;这里只看结构、文字与请求。 */
import { act } from 'react';
import { notifyManager, QueryClientProvider } from '@tanstack/react-query';
import { afterEach, expect, it, vi } from 'vitest';
import { queryClient } from '../../src/react/query';
import {
commonReviewSources, filterReviewRows, groupReviewRows, prefetchReview, REVIEW_DECISION_URL,
REVIEW_KEY, REVIEW_PAGE_SIZE, REVIEW_URL, reviewGroupingOptions, settleReviewRows,
reviewWindow, type ReviewCandidate, type ReviewData, type ReviewRow,
type DecisionResult,
} from '../../src/react/review/review';
import { AUTO_LANDINGS_URL, type AutoLandingWrite } from '../../src/react/review/auto-landings';
import { ReviewPage } from '../../src/react/review/review-page';
import { actionOrder, choose, click, mountRoot, settle } from './render';
// 客户端是模块级的单例(所有 React 根共用一个),用例之间不清就互相喂数据。
afterEach(() => queryClient.clear());
/* Query 派发更新用的是它自己抓住的那个真 `setTimeout(0)`,假时钟推不动它:推完时钟
断言到的还是上一帧的 DOM。用例里改成当场派发。 */
notifyManager.setScheduler((notify) => notify());
const candidate = (source: string, value: string): ReviewCandidate =>
({ candidate_key: `${source}:${value}`, source, display_value: value });
/** 一条元数据字段候选。`sources` 给几家就是几个候选,给一家就是单一来源。 */
const row = (at: number, sources: string[] = ['javdb', 'nfo']): ReviewRow => ({
item_key: `row-${at}`,
queue_order: at,
field: 'title',
field_label: '标题',
query: `ABC-${at}`,
candidates: sources.map((source) => candidate(source, `${source} 给的标题 ${at}`)),
});
/** 22 条多来源、3 条单一来源:够两页,也够两个分组。 */
const QUEUE: ReviewRow[] = [
...Array.from({ length: 22 }, (_, at) => row(at)),
...Array.from({ length: 3 }, (_, at) => row(100 + at, ['nfo'])),
];
const review = (over: Partial<ReviewData> = {}): ReviewData => ({
sections: { metadata_fields: QUEUE, creator_tags: [] },
counts: { metadata_fields: QUEUE.length, creator_tags: 0 },
queues: { later: { sections: {}, counts: {} }, ignored: { sections: {}, counts: {} } },
genre_tags: ['剧情'],
...over,
});
const ok = (body: unknown) => ({ ok: true, status: 200, json: async () => body });
interface Plan {
data?: ReviewData;
/** 判定的回答:给一串就按顺序一条一条回(最后一条之后一直回它)。 */
decisions?: DecisionResult[];
/** 「自动写入的资料」列出的条目;缺省没有,那一块不出现。 */
autoLandings?: AutoLandingWrite[];
}
function serve(plan: Plan = {}) {
const decisions = [...(plan.decisions ?? [{ ok: true }])];
const fetcher = vi.fn(async (input: string, _init?: RequestInit) => {
const url = String(input);
if (url === REVIEW_DECISION_URL) {
return ok(decisions.length > 1 ? decisions.shift()! : decisions[0]!);
}
if (url.startsWith(AUTO_LANDINGS_URL)) return ok({ items: plan.autoLandings ?? [] });
if (url.startsWith(REVIEW_URL)) return ok(plan.data ?? review());
throw new Error(`没有安排这个端点:${url}`);
});
vi.stubGlobal('fetch', fetcher);
return fetcher;
}
type Props = Parameters<typeof ReviewPage>[0];
const shellProps = (over: Partial<Props> = {}): Props => ({
category: '',
route: vi.fn(),
openItem: vi.fn(),
openEntity: vi.fn(),
revealSource: vi.fn(async () => ''),
toast: vi.fn(),
readOnly: false,
readOnlyMessage: '本机当前只能浏览',
writerUrl: '',
...over,
});
/** 走完真实的首屏路径:只取队列,然后挂载。 */
async function open(plan: Plan = {}, over: Partial<Props> = {}) {
const fetcher = serve(plan);
const props = shellProps(over);
await prefetchReview(new AbortController().signal).catch(() => {});
const mounted = await mountRoot(
<QueryClientProvider client={queryClient}><ReviewPage {...props} /></QueryClientProvider>);
await settle();
return { fetcher, props, ...mounted };
}
const cards = (root: ParentNode) => [...root.querySelectorAll('[data-review-key]')];
const keys = (root: ParentNode) => cards(root).map((card) => card.getAttribute('data-review-key'));
const boxOf = (root: ParentNode, at: number) =>
cards(root)[at]?.querySelector<HTMLInputElement>('input[type="checkbox"]');
const buttonIn = (root: ParentNode, name: string) =>
[...root.querySelectorAll('button')].find((button) => button.textContent?.trim() === name) ?? null;
const tabNamed = (root: ParentNode, name: string) =>
[...root.querySelectorAll('[role="tab"]')].find((tab) => tab.textContent?.startsWith(name)) ?? null;
const stateNamed = (root: ParentNode, name: string) =>
[...root.querySelectorAll('[aria-label="复核状态"] button')].find(button => button.textContent?.startsWith(name)) ?? null;
const statusText = (root: ParentNode) =>
[...root.querySelectorAll('[role="status"]')].map((node) => node.textContent?.trim());
it('展开来源依据不选择候选,也不提交资料判定', async () => {
const entry = row(1);
entry.candidates![0]!.catalog_evidence = { runtime: { display_value: '120 分钟' } };
const { host, fetcher } = await open({ data: review({ sections: { metadata_fields: [entry] } }) });
const card = cards(host)[0]!;
const toggle = card.querySelector('button[aria-label="展开 javdb 的来源依据"]')!;
expect(toggle.getAttribute('aria-expanded')).toBe('false');
await click(toggle);
expect(toggle.getAttribute('aria-expanded')).toBe('true');
expect([...card.querySelectorAll<HTMLInputElement>('input[type="radio"]')].every(input => !input.checked)).toBe(true);
expect(fetcher.mock.calls.some(([url]) => url === REVIEW_DECISION_URL)).toBe(false);
expect(card.textContent).toContain('120 分钟');
});
it('当前值独立显示人工归属,不混入旧说明中的维护实现细节', async () => {
const entry = { ...row(1), current_value: '用户整理的标题', current_owner: 'user:manual',
evidence: '旧说明里的维护脚本名称', videos: 1 };
const { host } = await open({ data: review({ sections: { metadata_fields: [entry] } }) });
const current = cards(host)[0]!.querySelector('[aria-label="当前信息"]')!;
expect(current.textContent).toContain('用户整理的标题');
expect(current.textContent).toContain('人工确认');
expect(current.textContent).not.toContain('旧说明里的维护脚本名称');
});
it('标题只标出不同文字,保留共同内容和原始候选值', async () => {
const before = '共同开头,旧的内容;共同结尾 😀';
const after = '共同开头,新的内容;共同结尾 😀';
const entry = { ...row(1, ['nfo']), current_value: before,
candidates: [candidate('nfo', after)] };
const { host, fetcher } = await open({ data: review({ sections: { metadata_fields: [entry] } }) });
const card = cards(host)[0]!;
const current = card.querySelector('[aria-label="当前信息"]')!;
expect(current.textContent).toContain(before);
expect(card.textContent).toContain(after);
expect([...card.querySelectorAll('mark')].map(mark => mark.textContent)).toEqual(['旧', '新']);
await click(buttonIn(card, '通过'));
const request = fetcher.mock.calls.find(([url]) => url === REVIEW_DECISION_URL)!;
expect(JSON.parse(request[1]!.body as string)).toMatchObject({ candidate_key: entry.candidates[0]!.candidate_key });
});
it('来源依据只对照同名字段,不把演员与标题当作差异', async () => {
const entry = { ...row(1), field: 'performers', field_label: '演员', current_value: '演员甲',
candidates: ['javdb', 'nfo'].map((source, at) => ({ ...candidate(source, '演员甲'),
catalog_evidence: { title: { display_value: `共同开头,${at ? '新的' : '旧的'}内容;共同结尾` } } })) };
const { host } = await open({ data: review({ sections: { metadata_fields: [entry] } }) });
const card = cards(host)[0]!;
const trigger = card.querySelector('button[aria-label="展开 javdb 的来源依据"]')!;
await click(trigger);
const panel = document.getElementById(trigger.getAttribute('aria-controls')!)!;
expect(panel.textContent).toContain('共同开头,旧的内容;共同结尾');
expect([...panel.querySelectorAll('mark')].map(mark => mark.textContent)).toEqual(['旧']);
expect(card.querySelector('[aria-label="当前信息"]')!.querySelectorAll('mark')).toHaveLength(0);
});
it('资料字段独立于来源分组筛选,并在全队列计数后重新分页', async () => {
const entries = [...QUEUE, ...[201, 202].map(at => ({ ...row(at), field: 'performers', field_label: '演员' }))];
const { host } = await open({ data: review({ sections: { metadata_fields: entries } }) });
await click(buttonIn(host, '下一页'));
await choose(host.querySelector('button[aria-label="筛选资料字段"]'), '演员 · 2');
expect(keys(host)).toEqual(['row-201', 'row-202']);
expect(buttonIn(host, '下一页')).toBeNull();
await choose(host.querySelector('button[aria-label="筛选分组方式"]'), '按来源');
expect(keys(host)).toEqual(['row-201', 'row-202']);
await choose(host.querySelector('button[aria-label="筛选资料字段"]'), '标题 · 25');
expect(cards(host)).toHaveLength(REVIEW_PAGE_SIZE);
expect(keys(host)[0]).toBe('row-0');
});
/** Note 按语气落在 `note`/`status`/`alert` 三种角色上。 */
const noteText = (root: ParentNode) =>
[...root.querySelectorAll('[role="note"], [role="status"], [role="alert"]')]
.map((node) => node.textContent);
const queueOf = () => queryClient.getQueryData<ReviewData>(REVIEW_KEY)!;
/** Shift 要从触发勾选的那一下事件里取:按下先于变更。 */
const pickRange = (box: Element | null | undefined) => act(async () => {
if (!box) throw new Error('勾选框没有画出来');
box.dispatchEvent(new MouseEvent('pointerdown', { bubbles: true, shiftKey: true }));
(box as HTMLInputElement).click();
});
it('分组、筛选与分页各按整条队列算,不是按屏幕上这一批', () => {
expect(reviewGroupingOptions(QUEUE, true).map(([key]) => key)).toEqual(['candidates', 'source', 'field']);
const groups = groupReviewRows(QUEUE, 'candidates');
expect(groups.map((group) => [group.title, group.rows.length]))
.toEqual([['需选择来源', 22], ['单一来源', 3]]);
expect(filterReviewRows(QUEUE, 'candidates', 'single')).toHaveLength(3);
expect(reviewWindow(QUEUE, 1).rows).toHaveLength(REVIEW_PAGE_SIZE);
expect(reviewWindow(QUEUE, 2)).toMatchObject({ page: 2, pages: 2 });
// 越界的页码收回到最后一页,不画一张空列表。
expect(reviewWindow(QUEUE, 9).page).toBe(2);
// 同一来源在一行里给了两个值时,「统一选 javdb」没有唯一答案。
expect(commonReviewSources(QUEUE.slice(0, 2))).toEqual(['javdb', 'nfo']);
expect(commonReviewSources([row(0, ['nfo', 'nfo'])])).toEqual([]);
});
it('一页只画二十张,翻页换的是哪二十行', async () => {
const { host } = await open();
expect(cards(host)).toHaveLength(REVIEW_PAGE_SIZE);
await click(buttonIn(host, '下一页'));
expect(keys(host)).toEqual(['row-20', 'row-21', 'row-100', 'row-101', 'row-102']);
});
it('筛掉一个分组之后回到第一页', async () => {
const { host } = await open();
await choose(host.querySelector('button[aria-label="筛选当前分类"]'), '单一来源 · 3');
expect(keys(host)).toEqual(['row-100', 'row-101', 'row-102']);
expect(buttonIn(host, '下一页')).toBeNull();
});
it('切换每页数量回到第一页并保留已选候选', async () => {
const { host } = await open();
await click(boxOf(host, 0));
await click(buttonIn(host, '下一页'));
await choose(host.querySelector('[data-table-pagination] button[aria-haspopup="listbox"]'), '每页 10 条');
expect(cards(host)).toHaveLength(10);
expect(keys(host)[0]).toBe('row-0');
expect(statusText(host)).toContain('已选 1 项');
await choose(host.querySelector('[data-table-pagination] button[aria-haspopup="listbox"]'), '每页 50 条');
expect(cards(host)).toHaveLength(QUEUE.length);
expect(buttonIn(host, '下一页')).toBeNull();
});
it('分类进地址栏,换一条队列就把手里的选择放下', async () => {
const { host, props } = await open();
expect(host.querySelector('[data-selection-dock]')).toBeNull();
await click(boxOf(host, 0));
expect(statusText(host)).toContain('已选 1 项');
expect(host.querySelector('[data-selection-dock]')).not.toBeNull();
await click(tabNamed(host, '创作者标签'));
expect(props.route).toHaveBeenCalledWith({ category: 'creator_tags', queue: '' });
expect(statusText(host)).not.toContain('已选 1 项');
expect(host.querySelector('[data-selection-dock]')).toBeNull();
// 默认那一档不写进地址栏。
await click(tabNamed(host, '元数据字段'));
expect(props.route).toHaveBeenLastCalledWith({ category: '', queue: '' });
});
it('Shift 选一段,翻页之后手里还是同一批', async () => {
const { host } = await open();
await click(boxOf(host, 1));
await pickRange(boxOf(host, 4));
expect(statusText(host)).toContain('已选 4 项');
await click(buttonIn(host, '下一页'));
// 上一页勾的那几条不在屏幕上,但仍在手里。
expect(boxOf(host, 0)?.checked).toBe(false);
await click(boxOf(host, 0));
expect(statusText(host)).toContain('已选 5 项');
});
it('判过的行从缓存里摘掉并同步计数,不为一次判定重取整条队列', async () => {
const { host, fetcher, props } = await open();
const reads = () => fetcher.mock.calls.filter(([url]) => String(url) === REVIEW_URL).length;
expect(reads()).toBe(1);
await click(buttonIn(cards(host)[0]!, '通过'));
await settle();
expect(props.toast).toHaveBeenCalledWith('已通过资料');
expect(queueOf().sections.metadata_fields).toHaveLength(QUEUE.length - 1);
expect(queueOf().counts.metadata_fields).toBe(QUEUE.length - 1);
expect(keys(host)).not.toContain('row-0');
expect(reads()).toBe(1);
});
it('服务端拒绝这次判定时说出原因,那一行留在屏幕上', async () => {
const { host, props } = await open({ decisions: [{ ok: false, error: '字段已有值' }] });
await click(buttonIn(cards(host)[0]!, '通过'));
await settle();
expect(cards(host)[0]?.textContent).toContain('字段已有值');
expect(props.toast).not.toHaveBeenCalled();
expect(queueOf().sections.metadata_fields).toHaveLength(QUEUE.length);
});
it('批量判定把成功的摘掉,没写成的留下来等重试', async () => {
const { host, props } = await open({
decisions: [{ ok: true }, { ok: false, error: '来源已失效' }, { ok: true }],
});
await choose(host.querySelector('button[aria-label="筛选当前分类"]'), '单一来源 · 3');
await click(buttonIn(host, '全选当前分类'));
expect(statusText(host)).toContain('已选 3 项');
expect(actionOrder(buttonIn(host, '通过所选')!.parentElement).filter((name) => name.endsWith('所选') || name === '取消选择'))
.toEqual(['忽略所选', '稍后处理所选', '通过所选', '取消选择']);
await click(buttonIn(host, '通过所选'));
await settle();
expect(props.toast).toHaveBeenCalledWith('已通过 2 项,1 项未完成');
expect(queueOf().sections.metadata_fields).toHaveLength(QUEUE.length - 2);
expect(keys(host)).toEqual(['row-101']);
expect(cards(host)[0]?.textContent).toContain('来源已失效');
});
const sameAssetRows = (): ReviewRow[] => [0, 1, 2].map((at) => ({
...row(at, ['javdb']), asset_id: 6, asset_path: '/media/ABC-123.mp4',
asset_mutation_revision: at === 2 ? 0 : 1,
}));
const receipt = (before: number, after: number): DecisionResult =>
({ ok: true, asset_revisions: { '6': { before, after } } });
const sentDecisions = (fetcher: ReturnType<typeof serve>) => fetcher.mock.calls
.filter(([url]) => url === REVIEW_DECISION_URL)
.map((call) => JSON.parse((call[1] as RequestInit).body as string));
it('逐项通过使用同资产最近一次批准的版本,已过期的候选保持原版本', async () => {
const { host, fetcher } = await open({
data: review({ sections: { metadata_fields: sameAssetRows() } }),
decisions: [receipt(1, 4), receipt(4, 5)],
});
await click(buttonIn(cards(host)[0]!, '通过'));
await settle();
expect(queueOf().sections.metadata_fields?.map((item) => item.asset_mutation_revision)).toEqual([4, 0]);
await click(buttonIn(cards(host)[0]!, '通过'));
await settle();
expect(sentDecisions(fetcher).map((body) => body.expected_revision)).toEqual([1, 4]);
});
it('批量通过逐条沿用服务端版本回执,并保留其他写入造成的冲突', async () => {
const { host, fetcher } = await open({
data: review({ sections: { metadata_fields: sameAssetRows() } }),
decisions: [receipt(1, 4), receipt(4, 5), { ok: false, error: '资产资料已更改' }],
});
await click(buttonIn(host, '全选本页'));
await click(buttonIn(host, '通过所选'));
await settle();
expect(sentDecisions(fetcher).map((body) => body.expected_revision)).toEqual([1, 4, 0]);
expect(keys(host)).toEqual(['row-2']);
expect(cards(host)[0]?.textContent).toContain('资产资料已更改');
});
it('多来源候选没选来源就批量通过时先说清楚,不替人按下判断', async () => {
const { host } = await open();
await click(buttonIn(host, '全选本页'));
await click(buttonIn(host, '通过所选'));
await settle();
expect(statusText(host)).toContain('请先为所选资料选择要采用的来源。');
expect(queueOf().sections.metadata_fields).toHaveLength(QUEUE.length);
});
it('只读数据库上判定与批量都不给点', async () => {
const { host, fetcher } = await open(
{ data: review({ mirror: { state: 'live' } }) },
{ readOnly: true, writerUrl: 'https://writer.example/review' });
// 只读:队列与自动写入批次各读一次,一个写请求都不发。
expect(fetcher.mock.calls.map(([url]) => String(url)).sort()).toEqual([REVIEW_URL, AUTO_LANDINGS_URL]);
expect(fetcher.mock.calls.every(([, init]) => !init?.method || init.method === 'GET')).toBe(true);
expect(noteText(host).join()).toContain('正在显示写入端的实时复核队列');
expect(host.querySelector('a[href="https://writer.example/review"]')).toBeTruthy();
// 勾选与批量操作整条都不出现:没有可写的东西,工具条只是一排点不动的按钮。
expect(boxOf(host, 0)).toBeFalsy();
expect(buttonIn(host, '全选本页')).toBeNull();
for (const name of ['通过', '忽略', '稍后处理']) {
expect(buttonIn(cards(host)[0]!, name)).toHaveProperty('disabled', true);
}
});
it('打开复核页只读队列,不再触发自动落库写操作', async () => {
const { fetcher } = await open();
// 读两样:复核队列与「自动写入的资料」的批次列表;都是 GET。
expect(fetcher.mock.calls.map(([url]) => String(url)).sort()).toEqual([REVIEW_URL, AUTO_LANDINGS_URL]);
expect(fetcher.mock.calls.every(([, init]) => !init?.method || init.method === 'GET')).toBe(true);
});
it('稍后处理切换独立队列,刷新地址可还原且恢复保持原排序', async () => {
const { host, props } = await open();
await click(buttonIn(cards(host)[1]!, '稍后处理'));
await settle();
expect(queueOf().counts.metadata_fields).toBe(24);
expect(queueOf().queues.later.counts.metadata_fields).toBe(1);
await click(stateNamed(host, '稍后处理'));
expect(props.route).toHaveBeenLastCalledWith({ category: '', queue: 'later' });
expect(keys(host)).toEqual(['row-1']);
expect(buttonIn(cards(host)[0]!, '恢复待处理')).toBeTruthy();
await click(buttonIn(cards(host)[0]!, '恢复待处理'));
await settle();
expect(queueOf().queues.later.counts.metadata_fields).toBe(0);
expect(queueOf().sections.metadata_fields?.slice(0, 3).map(row => row.item_key))
.toEqual(['row-0', 'row-1', 'row-2']);
await click(stateNamed(host, '待处理'));
expect(keys(host).slice(0, 3)).toEqual(['row-0', 'row-1', 'row-2']);
});
it('已忽略通过链接打开,只提供恢复,跨状态清空选择', async () => {
const data = review({ queues: {
later: { sections: {}, counts: {} },
ignored: { sections: { metadata_fields: [{ ...row(7), decision: 'rejected' }] },
counts: { metadata_fields: 1 } },
} });
const { host, props } = await open({ data }, { queue: 'ignored' });
expect(keys(host)).toEqual(['row-7']);
expect(buttonIn(cards(host)[0]!, '通过')).toBeNull();
expect(buttonIn(cards(host)[0]!, '恢复待处理')).toBeTruthy();
await click(boxOf(host, 0));
expect(buttonIn(host, '恢复所选')).toBeTruthy();
expect(buttonIn(host, '通过所选')).toBeNull();
await click(stateNamed(host, '待处理'));
expect(props.route).toHaveBeenLastCalledWith({ category: '', queue: '' });
expect(host.querySelector('[data-selection-dock]')).toBeNull();
});
it('空分类仍可在筛选浮窗切换状态,只读时保留筛选并隐藏全选', async () => {
const { host, props } = await open({ data: review({
sections: { metadata_fields: [] }, counts: { metadata_fields: 0 },
}) }, { readOnly: true });
const filter = host.querySelector('[aria-label="复核筛选"]');
expect(filter?.querySelector('[aria-label="复核状态"]')).toBeTruthy();
expect(buttonIn(filter!, '全选本页')).toBeNull();
await click(stateNamed(filter!, '已忽略'));
expect(props.route).toHaveBeenLastCalledWith({ category: '', queue: 'ignored' });
expect(host.textContent).toContain('此分类没有已忽略项目');
expect(filter?.querySelector('[aria-label="复核状态"]')).toBeTruthy();
});
it('批量状态移动只采用成功项,失败行和其他类别保持不变', () => {
queryClient.setQueryData(REVIEW_KEY, review());
settleReviewRows('metadata_fields', ['row-1', 'row-2'], 'rejected');
const data = queueOf();
expect(data.counts.metadata_fields).toBe(23);
expect(data.queues.ignored.sections.metadata_fields?.map(row => row.item_key))
.toEqual(['row-1', 'row-2']);
expect(data.sections.metadata_fields?.some(row => row.item_key === 'row-0')).toBe(true);
expect(data.sections.creator_tags).toEqual([]);
settleReviewRows('metadata_fields', ['row-1'], 'restore');
expect(queueOf().queues.ignored.counts.metadata_fields).toBe(1);
expect(queueOf().counts.metadata_fields).toBe(24);
});
it('批量稍后处理失败的行留在待处理,成功行进入独立队列', async () => {
const rows = [row(0, ['nfo']), row(1, ['nfo']), row(2, ['nfo'])];
const { host } = await open({
data: review({ sections: { metadata_fields: rows }, counts: { metadata_fields: 3 } }),
decisions: [{ ok: true }, { ok: false, error: '候选已变更' }, { ok: true }],
});
await click(buttonIn(host, '全选本页'));
await click(buttonIn(host, '稍后处理所选'));
await settle();
expect(keys(host)).toEqual(['row-1']);
expect(cards(host)[0]?.textContent).toContain('候选已变更');
expect(queueOf().counts.metadata_fields).toBe(1);
expect(queueOf().queues.later.counts.metadata_fields).toBe(2);
await click(stateNamed(host, '稍后处理'));
expect(keys(host)).toEqual(['row-0', 'row-2']);
expect(host.querySelector('[data-selection-dock]')).toBeNull();
});
it('队列读取失败时说读取失败、给重试键,和空队列分得开;重试成功后画出队列', async () => {
let fail = true;
vi.stubGlobal('fetch', vi.fn(async (input: string) => {
if (!String(input).startsWith(REVIEW_URL)) throw new Error(`没有安排这个端点:${String(input)}`);
return fail
? { ok: false, status: 500, json: async () => ({ message: '复核队列查询出错' }) }
: ok(review());
}));
await prefetchReview(new AbortController().signal).catch(() => {});
const { host } = await mountRoot(
<QueryClientProvider client={queryClient}><ReviewPage {...shellProps()} /></QueryClientProvider>);
await settle();
expect(host.textContent).toContain('复核队列读取失败');
expect(host.textContent).not.toContain('此分类没有待复核项目');
fail = false;
await click(buttonIn(host, '立即重试'));
await settle();
expect(host.textContent).not.toContain('复核队列读取失败');
expect(cards(host)).toHaveLength(REVIEW_PAGE_SIZE);
});
it('没有可采纳候选的卡仍可忽略或稍后处理,通过键不可用', async () => {
const empty: ReviewRow = { ...row(7), candidates: [] };
const { host } = await open({ data: review({ sections: { metadata_fields: [empty], creator_tags: [] } }) });
const footer = cards(host)[0]!.querySelector('footer')!;
expect([...footer.querySelectorAll('button')].map((button) => button.textContent?.trim()))
.toEqual(['忽略', '稍后处理', '不可通过']);
});
const WRITES: AutoLandingWrite[] = [
{ item_key: 'DASS-468:release_date', rule: 'adr-0139-official-replaces-verified', label: '官方来源一致,覆盖原值',
batch: 'adr-0139-official-replaces-verified@20261104T141053', at: 1793772653, field: '发行日期',
value: '2024-09-10', previous: ['2024-09-06'], tags: [], assets: 1,
asset_id: 7, code: 'DASS-468', name: '某部作品的标题', preview_url: '' },
{ item_key: 'ROYD-083:tags', rule: 'adr-0139-verified-tags-union', label: '补上来源多给的标签',
batch: 'auto:metadata-tags@20261104T141053', at: 1793772653, field: '标签',
value: '痴女、姐弟', previous: [], tags: ['痴女', '姐弟'], assets: 1,
asset_id: 8, code: 'ROYD-083', name: '另一部作品', preview_url: '' },
];
it('元数据字段下逐条列出自动写入:作品、写了什么、原来是什么,只读端也能浏览', async () => {
const { host } = await open({ autoLandings: WRITES }, { readOnly: true });
const section = host.querySelector('[aria-labelledby="auto-landings-title"]')!;
const text = section.textContent ?? '';
for (const expected of ['自动写入的资料', 'DASS-468', '某部作品的标题', '发行日期:2024-09-10', '原为 「2024-09-06」',
'ROYD-083', '标签:痴女、姐弟', '原有标签保留']) expect(text).toContain(expected);
});
it('没有自动写入时不出现那一块', async () => {
const { host } = await open();
expect(host.querySelector('[aria-labelledby="auto-landings-title"]')).toBeNull();
});