Files
quality_analyse/web/verification/analysis_submission.test.mjs
T
lyun f1a2fbd494 统一:DSH 智能分析、Top100 与图表静默恢复
接入 DSH 专用运行时和对话界面,保留模型原始回答,支持会话分页、连续追问与显式报告。
补齐组合筛选、各维度 Top100、分组查询到排名图的转换,图表故障静默省略并基于保存数据自动恢复。
优化报告风格、图表顺序和表格换行,更新接入说明及构建输入。

验证:独立目录前后端构建通过;118 项 Java、102 项前端、102 项图表、14 项 DSH 应用和 13 项组合筛选检查通过。
仅提交相关源码、锁定依赖与测试;不包含凭据、会话、业务数据或本地产物。
2026-11-12 11:57:41 +08:00

322 lines
15 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { beginAnalysisSubmission, submissionOutcomeUnknown } from '../src/analysisSubmission.ts';
import { createAnalysisSessionClient } from '../src/agent/sessionClient.ts';
const tick = () => new Promise(resolve => setImmediate(resolve));
const deferred = () => {
let resolve, reject;
const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
return { promise, resolve, reject };
};
const saved = (id, status, extras = {}) => ({ id, question: 'saved question', status, ...extras });
const page = (id, turns = [], extra = {}) => ({ id, turns, ...extra });
function fixture(t, overrides = {}, initialPages = { 'session-1': page('session-1') }) {
const pages = { ...initialPages };
const requests = { starts: [], cancels: [], retries: [], follows: [] };
const transport = {
analysisSessions: async () => ({ items: Object.keys(pages).map(id => ({ id })) }),
analysisSessionFollow: (id, { signal, onEvent }) => {
const end = deferred();
requests.follows.push({ id, emit: onEvent, close: end.resolve });
signal.addEventListener('abort', end.resolve, { once: true });
onEvent({ event: 'snapshot', data: pages[id] || page(id) });
return end.promise;
},
createAnalysisSession: async () => ({ session: { id: 'session-1' } }),
startAnalysisTurn: async (id, body) => {
requests.starts.push({ id, ...body });
const turn = saved('turn-1', 'QUEUED', { sessionId: id, question: body.question });
pages[id] = page(id, [...(pages[id]?.turns || []), turn], { activeTurnId: turn.id });
return { turn };
},
retryAnalysisTurn: async id => { requests.retries.push(id); throw new Error('Unexpected retry'); },
cancelAnalysisTurn: async id => {
requests.cancels.push(id);
for (const [sessionId, previous] of Object.entries(pages)) {
const turns = previous.turns.map(turn => turn.id === id ? { ...turn, status: 'CANCELLED' } : turn);
pages[sessionId] = { ...previous, turns, activeTurnId: previous.activeTurnId === id ? '' : previous.activeTurnId };
}
return { status: 'CANCELLED', turnId: id };
},
...overrides,
};
const client = createAnalysisSessionClient({ userId: 'submission-fixture', transport });
t.after(client.dispose);
return { client, pages, requests, state: client.getSnapshot };
}
test('read-only history cannot submit or retry and keeps its saved turn', async t => {
const legacy = saved('legacy-turn', 'FAILED', { result: { answer: 'saved answer' } });
const { client, requests, state } = fixture(t, {}, { 'session-1': page('session-1', [legacy], { readOnly: true }) });
await client.openSession('session-1');
assert.equal(await client.submit('new question'), false);
assert.equal(await client.retry('legacy-turn'), false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(requests.retries, []);
assert.equal(state().turns[0].result.answer, 'saved answer');
assert.equal(state().busy, false);
assert.equal(state().queuedQuestion, '');
});
test('unknown result retries reuse the key only for identical frozen submission', () => {
const input = { sessionId: 's', question: 'q', generation: 1, context: { month: 9, year: 2026 } };
const prior = beginAnalysisSubmission(null, input, () => 'first-key');
prior.uncertain = true;
prior.inFlight = false;
assert.equal(beginAnalysisSubmission(prior, { ...input, context: { year: 2026, month: 9 } }, () => 'new-key'), prior);
for (const change of [{ question: 'other' }, { sessionId: 'other' }, { generation: 2 }, { context: { month: 8, year: 2026 } }]) {
assert.equal(beginAnalysisSubmission(prior, { ...input, ...change }, () => 'new-key').idempotencyKey, 'new-key');
}
});
test('explicit client rejection differs from an unknown network/server outcome', () => {
for (const status of [400, 401, 403, 404, 409, 413, 422, 429]) assert.equal(submissionOutcomeUnknown({ status }), false);
for (const status of [0, 200, 408, 500, 502, 503]) assert.equal(submissionOutcomeUnknown({ status }), true);
assert.equal(submissionOutcomeUnknown(new Error('connection lost')), true);
});
test('stop during turn creation is fulfilled once the receipt identifies the turn', async t => {
const receipt = deferred();
const { client, pages, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = saved('turn-1', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: 'turn-1' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['turn-1']);
assert.equal(state().turns.at(-1).status, 'CANCELLED');
assert.equal(state().busy, false);
});
test('stop before the new session is created prevents a model turn from starting', async t => {
const created = deferred();
const { client, requests, state } = fixture(t, { createAnalysisSession: () => created.promise }, {});
const pending = client.submit('q');
assert.equal(await client.cancel(), true);
created.resolve({ session: { id: 'new-session' } });
assert.equal(await pending, false);
assert.deepEqual(requests.starts, []);
assert.deepEqual(state().turns, []);
assert.equal(state().pendingQuestion, '');
assert.equal(state().busy, false);
});
test('a follow-up waits for the accepted task to settle and then sends once', async t => {
const { client, requests, pages, state } = fixture(t);
await client.openSession('session-1');
assert.equal(await client.submit('initial question'), true);
await tick();
assert.equal(await client.submit('follow-up question'), true);
assert.equal(await client.submit('second queued question'), false);
assert.equal(state().queuedQuestion, 'follow-up question');
assert.deepEqual(requests.starts.map(request => request.question), ['initial question']);
pages['session-1'] = page('session-1', [saved('turn-1', 'COMPLETED', { question: 'initial question' })]);
const current = requests.follows.at(-1);
current.emit({ id: '1', event: 'completed', data: { turnId: 'turn-1', result: { answer: 'done' } } });
current.close();
await tick();
requests.follows.at(-1).close();
await tick();
assert.deepEqual(requests.starts.map(request => request.question), ['initial question', 'follow-up question']);
assert.equal(state().queuedQuestion, '');
});
test('session-list refresh cannot delay following or the stop target', async t => {
const list = deferred();
const { client, requests, state } = fixture(t, { analysisSessions: () => list.promise });
await client.openSession('session-1');
assert.equal(await client.submit('q'), true);
await tick();
assert.equal(state().sessionsLoading, true);
assert.equal(requests.follows.length, 2);
assert.equal(state().activeTurnId, 'turn-1');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, ['turn-1']);
list.resolve({ items: [] });
});
test('a lost accepted response retries the same key without archiving a phantom turn', async t => {
const bodies = [];
const { client, pages, state } = fixture(t, {
startAnalysisTurn: async (id, body) => {
bodies.push(body);
if (bodies.length === 1) throw Object.assign(new Error('service unavailable'), { status: 503 });
const turn = saved('original-turn', 'RUNNING', { question: body.question });
pages[id] = page(id, [turn], { activeTurnId: turn.id });
return { turn };
},
});
await client.openSession('session-1');
assert.equal(await client.submit('q'), false);
assert.equal(state().retryQuestion, 'q');
assert.equal(state().error, 'service unavailable');
assert.equal(state().busy, false);
assert.equal(state().activeTurnId, '');
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), true);
assert.equal(bodies.length, 2);
assert.equal(bodies[0].idempotencyKey, bodies[1].idempotencyKey);
assert.deepEqual(state().turns.map(turn => turn.id), ['original-turn']);
});
test('an explicit 400 rejection gives the same editable question a fresh key without showing it as running', async t => {
const keys = [];
const { client, state } = fixture(t, {
startAnalysisTurn: async (_id, body) => {
keys.push(body.idempotencyKey);
throw Object.assign(new Error('invalid question'), { status: 400 });
},
});
await client.openSession('session-1');
assert.equal(await client.submit('rejected question'), false);
assert.equal(state().retryQuestion, 'rejected question');
assert.equal(state().error, 'invalid question');
assert.equal(state().busy, false);
assert.deepEqual(state().turns, []);
assert.equal(await client.submit(state().retryQuestion), false);
assert.notEqual(keys[0], keys[1]);
});
test('a pending stop applies only to its original turn after navigation', async t => {
const receipt = deferred();
const { client, requests, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('q');
await tick();
assert.equal(await client.cancel(), true);
await client.openSession('session-2');
receipt.resolve({ turn: saved('old-turn', 'RUNNING', { sessionId: 'session-1' }) });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['old-turn']);
assert.deepEqual(state().turns, []);
assert.equal(state().activeTurnId, '');
assert.equal(state().sessionId, 'session-2');
});
test('stop during retry waits for requeue and targets the original saved turn', async t => {
const receipt = deferred();
const savedTurn = saved('partial-turn', 'PARTIAL');
const { client, pages, requests, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [savedTurn, saved('newest-turn', 'COMPLETED')]),
});
await client.openSession('session-1');
const pending = client.retry('partial-turn');
assert.equal(await client.cancel(), true);
assert.deepEqual(requests.cancels, []);
const turn = { ...savedTurn, status: 'QUEUED' };
pages['session-1'] = page('session-1', [turn, saved('newest-turn', 'COMPLETED')], { activeTurnId: 'partial-turn' });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.deepEqual(requests.cancels, ['partial-turn']);
assert.equal(state().busy, false);
assert.equal(state().turns.find(row => row.id === 'partial-turn').status, 'CANCELLED');
});
test('a late cancellation failure cannot put an error in a newly selected session', async t => {
const cancel = deferred();
const { client, state } = fixture(t, { cancelAnalysisTurn: () => cancel.promise });
await client.openSession('session-1');
await client.submit('q');
const stopping = client.cancel();
await client.openSession('other');
cancel.reject(new Error('cancellation response lost'));
assert.equal(await stopping, false);
assert.equal(state().error, '');
assert.deepEqual(state().turns, []);
});
test('repeated stop clicks share one request until the task settles', async t => {
const cancellation = deferred();
let count = 0;
const { client, pages, state } = fixture(t, { cancelAnalysisTurn: () => { count++; return cancellation.promise; } });
await client.openSession('session-1');
await client.submit('q');
const first = client.cancel();
assert.equal(await client.cancel(), false);
assert.equal(count, 1);
assert.equal(state().stopping, true);
pages['session-1'] = page('session-1', [saved('turn-1', 'CANCELLED')]);
cancellation.resolve({ status: 'CANCELLED', turnId: 'turn-1' });
assert.equal(await first, true);
assert.equal(state().busy, false);
});
test('stopping keeps the queued question available for editing and does not send it', async t => {
const { client, requests, state } = fixture(t);
await client.openSession('session-1');
await client.submit('initial');
await client.submit('queued follow-up');
await client.cancel();
await tick();
requests.follows.at(-1).close();
await tick();
assert.equal(state().queuedQuestion, 'queued follow-up');
assert.deepEqual(requests.starts.map(request => request.question), ['initial']);
assert.equal(client.takeQueued(), 'queued follow-up');
assert.equal(state().queuedQuestion, '');
});
test('a failed stop request allows another explicit stop attempt', async t => {
let count = 0;
const { client, pages, state } = fixture(t, {
cancelAnalysisTurn: async id => {
if (++count === 1) throw new Error('offline');
pages['session-1'] = page('session-1', [saved(id, 'CANCELLED')]);
return { status: 'CANCELLED', turnId: id };
},
});
await client.openSession('session-1');
await client.submit('initial');
assert.equal(await client.cancel(), false);
assert.equal(state().stopping, false);
assert.equal(state().busy, true);
assert.equal(await client.cancel(), true);
assert.equal(count, 2);
assert.equal(state().busy, false);
});
test('a fresh submission immediately carries waiting status and a clock before acceptance', async t => {
const receipt = deferred();
const { client, pages, state } = fixture(t, { startAnalysisTurn: () => receipt.promise });
await client.openSession('session-1');
const pending = client.submit('即时状态');
assert.equal(state().turns.at(-1).status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1)._uiSubmittedAt)));
const turn = saved('accepted', 'RUNNING', { question: '即时状态', createdAt: new Date().toISOString() });
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
assert.equal(state().turns.at(-1).id, 'accepted');
assert.ok(Number.isFinite(Date.parse(state().turns.at(-1).createdAt)));
});
test('retry starts a fresh waiting clock without the old answer or plan clock', async t => {
const receipt = deferred();
const old = saved('old', 'PARTIAL', {
answer: 'old text', createdAt: '2020-01-01T00:00:00Z', startedAt: '2020-01-01T00:00:01Z',
plan: { startedAt: '2020-01-01T00:00:01Z' },
});
const { client, pages, state } = fixture(t, { retryAnalysisTurn: () => receipt.promise }, {
'session-1': page('session-1', [old]),
});
await client.openSession('session-1');
const pending = client.retry('old');
const current = state().turns[0];
assert.equal(current.status, 'SUBMITTING');
assert.ok(Number.isFinite(Date.parse(current._uiSubmittedAt)));
assert.equal(current.answer, undefined);
assert.equal(current.plan, undefined);
assert.equal(current.startedAt, undefined);
const turn = saved('old', 'QUEUED');
pages['session-1'] = page('session-1', [turn], { activeTurnId: turn.id });
receipt.resolve({ turn });
assert.equal(await pending, true);
});