john
339 lines
13 KiB
JavaScript
339 lines
13 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
import crypto from 'node:crypto';
|
|
import {
|
|
createAgentRun,
|
|
createReporter,
|
|
extractAssistantTexts,
|
|
getSession,
|
|
loginViaApi,
|
|
logoutViaApi,
|
|
waitForRunTerminal,
|
|
} from './scenario-test-lib.mjs';
|
|
|
|
const baseUrl = process.env.MEMIND_E2E_BASE_URL ?? 'http://127.0.0.1:8081';
|
|
const username = process.env.MEMIND_E2E_USERNAME ?? 'john4';
|
|
const password = process.env.MEMIND_E2E_PASSWORD ?? '888888';
|
|
const userId = process.env.MEMIND_E2E_USER_ID ?? '32035858-9a20-425b-89da-c118ef0779aa';
|
|
const pageName = process.env.MEMIND_E2E_PAGE_NAME ?? 'durability-survey-20260727.html';
|
|
const pageUrl = `${baseUrl}/MindSpace/${userId}/public/${pageName}`;
|
|
const timeoutMs = Number(process.env.MEMIND_E2E_RUN_TIMEOUT_MS ?? 180_000);
|
|
const startTurn = Math.max(
|
|
1,
|
|
Math.min(21, Number(process.env.MEMIND_E2E_START_TURN ?? 1) || 1),
|
|
);
|
|
const resumeSessionId = String(process.env.MEMIND_E2E_RESUME_SESSION_ID ?? '').trim() || null;
|
|
|
|
const editTurns = [
|
|
'创建一个单页“小问卷耐久测试系统”：包含标题、昵称输入、一个基础单选问题、提交按钮和页内结果区；答案只保存在当前页面内存中，不做网络提交。创建可见的 <details><ol id="durability-log"></ol></details> 验收记录。',
|
|
'新增“年龄段”下拉选择题，并在结果区显示对应中文标签。',
|
|
'新增“最喜欢的活动”多选题，至少包含阅读、运动、音乐和旅行。',
|
|
'新增“每周参与频率”单选题，包含偶尔、每周、每天。',
|
|
'新增“你最期待的改进”多行文本题，并限制为 200 字。',
|
|
'给必填题增加页内校验和 role="alert" 错误提示，不允许用浏览器弹窗替代。',
|
|
'新增实时答题进度条，按已回答题目数量更新百分比。',
|
|
'把问卷改成两步填写，加入上一步和下一步按钮；最后一步才能提交。',
|
|
'提交前增加答案复核区域，可返回修改后再确认。',
|
|
'把视觉主题调整为蓝绿色卡片风格，保持现有功能和数据结构。',
|
|
'增加 prefers-color-scheme 深色模式样式，但不要持久化主题状态。',
|
|
'优化手机窄屏布局，按钮在小屏幕下堆叠且可触摸区域不小于 44px。',
|
|
'完善可访问性：题组使用 fieldset/legend，输入与标签关联，并提供清晰的 :focus-visible。',
|
|
'新增“重新填写”按钮，重置表单、进度、复核区和结果区。',
|
|
'提交成功后显示温和的页内完成提示，不使用 alert。',
|
|
'在完成结果中显示本次提交的本地时间，刷新页面后不需要保留。',
|
|
'结果区按题目中文名称逐项展示答案，不能只输出原始字段名。',
|
|
'新增“打印结果”按钮，调用 window.print()，并添加简洁的 @media print 样式。',
|
|
'新增问卷版本徽标 v1.0 和“最后更新：耐久测试第 19 轮”文案。',
|
|
'新增键盘友好的跳过链接，可直接跳到问卷正文和结果区域。',
|
|
'做最终一致性整理：保留全部问题、两步导航、校验、复核、重置、打印、深色模式和移动端样式，并在页脚写“21 轮持续修改验收完成”。',
|
|
];
|
|
|
|
const phaseEnds = new Set([6, 12, 18]);
|
|
const statusAfter = new Map([
|
|
[6, 'STATUS-AFTER-06'],
|
|
[12, 'STATUS-AFTER-12'],
|
|
[18, 'STATUS-AFTER-18'],
|
|
]);
|
|
const completedEditCodes = [];
|
|
const runRecords = [];
|
|
const reporter = createReporter();
|
|
let auth = null;
|
|
let sessionId = resumeSessionId;
|
|
let loginCount = 0;
|
|
|
|
for (let turnNumber = 1; turnNumber < startTurn; turnNumber += 1) {
|
|
completedEditCodes.push({
|
|
code: turnCode(turnNumber),
|
|
marker: turnMarker(turnNumber),
|
|
});
|
|
}
|
|
|
|
function assert(condition, message) {
|
|
if (!condition) throw new Error(message);
|
|
}
|
|
|
|
function hashText(text) {
|
|
return crypto.createHash('sha256').update(text).digest('hex');
|
|
}
|
|
|
|
function turnCode(turnNumber) {
|
|
return `DURABILITY-${String(turnNumber).padStart(2, '0')}`;
|
|
}
|
|
|
|
function turnMarker(turnNumber) {
|
|
return `durability-turn-${String(turnNumber).padStart(2, '0')}`;
|
|
}
|
|
|
|
async function login(label) {
|
|
auth = await loginViaApi(baseUrl, { username, password }, reporter);
|
|
loginCount += 1;
|
|
console.log(`[auth] ${label}: login #${loginCount}`);
|
|
if (sessionId) {
|
|
const result = await getSession(baseUrl, auth.cookie, sessionId);
|
|
assert(result.ok, `[auth] ${label}: session ${sessionId} unavailable after login`);
|
|
const transcript = extractAssistantTexts(result.session).join('\n');
|
|
const expected = completedEditCodes.at(-1)?.code;
|
|
if (expected) {
|
|
assert(
|
|
transcript.includes(expected),
|
|
`[auth] ${label}: restored transcript is missing ${expected}`,
|
|
);
|
|
}
|
|
console.log(`[auth] ${label}: restored session ${sessionId} with ${expected ?? 'no prior code'}`);
|
|
}
|
|
}
|
|
|
|
async function logout(label) {
|
|
assert(auth?.cookie, `[auth] ${label}: no active login`);
|
|
await logoutViaApi(baseUrl, auth.cookie, reporter);
|
|
auth = null;
|
|
console.log(`[auth] ${label}: logout complete`);
|
|
}
|
|
|
|
async function fetchPage() {
|
|
const response = await fetch(pageUrl, {
|
|
headers: auth?.cookie ? { Cookie: auth.cookie } : {},
|
|
});
|
|
const text = await response.text();
|
|
assert(response.ok, `page ${pageUrl} returned ${response.status}`);
|
|
return text;
|
|
}
|
|
|
|
async function assertSessionReply(expectedCode) {
|
|
const result = await getSession(baseUrl, auth.cookie, sessionId);
|
|
assert(result.ok, `session ${sessionId} returned ${result.status}`);
|
|
const assistantTexts = extractAssistantTexts(result.session);
|
|
const transcript = assistantTexts.join('\n');
|
|
assert(
|
|
transcript.includes(expectedCode),
|
|
`session ${sessionId} assistant transcript is missing ${expectedCode}`,
|
|
);
|
|
return {
|
|
assistantCount: assistantTexts.length,
|
|
transcriptLength: transcript.length,
|
|
};
|
|
}
|
|
|
|
function buildEditPrompt(turnNumber, instruction) {
|
|
const code = turnCode(turnNumber);
|
|
const marker = turnMarker(turnNumber);
|
|
if (turnNumber === 1) {
|
|
return [
|
|
`这是持续对话耐久测试第 ${turnNumber}/21 轮。`,
|
|
`请创建 public/${pageName}。${instruction}`,
|
|
`在 #durability-log 末尾加入 <li id="${marker}">${code}</li>。`,
|
|
'禁止调用任何图片工具；禁止使用 localStorage、sessionStorage、IndexedDB 或 Cookie。',
|
|
`最终回复必须包含验收码 ${code} 和页面链接。`,
|
|
].join('\n');
|
|
}
|
|
return [
|
|
`这是持续对话耐久测试第 ${turnNumber}/21 轮。`,
|
|
`继续修改同一个 public/${pageName}，不要新建页面。`,
|
|
'必须保留之前所有功能与所有 durability-turn-* 验收标记。',
|
|
instruction,
|
|
`在 #durability-log 末尾加入 <li id="${marker}">${code}</li>。`,
|
|
'禁止调用任何图片工具；禁止使用 localStorage、sessionStorage、IndexedDB 或 Cookie。',
|
|
`最终回复必须包含验收码 ${code} 和页面链接。`,
|
|
].join('\n');
|
|
}
|
|
|
|
async function createRunWithOptionalConflict(turnNumber, message, { probeConflict = false } = {}) {
|
|
const created = await createAgentRun(baseUrl, auth.cookie, {
|
|
message,
|
|
sessionId,
|
|
});
|
|
|
|
if (probeConflict) {
|
|
let conflictError = null;
|
|
try {
|
|
await createAgentRun(baseUrl, auth.cookie, {
|
|
message: `并发探针 ${turnCode(turnNumber)}：这条请求必须被同会话并发保护拒绝。`,
|
|
sessionId: created.sessionId ?? sessionId,
|
|
});
|
|
} catch (error) {
|
|
conflictError = error;
|
|
}
|
|
const conflictText = String(conflictError?.message ?? '');
|
|
assert(
|
|
/409/.test(conflictText) && /SESSION_RUN_CONFLICT/.test(conflictText),
|
|
`turn ${turnNumber}: expected SESSION_RUN_CONFLICT, got ${conflictText || 'no error'}`,
|
|
);
|
|
console.log(`[conflict] turn ${turnNumber}: expected 409 SESSION_RUN_CONFLICT`);
|
|
}
|
|
|
|
return created;
|
|
}
|
|
|
|
async function runEditTurn(turnNumber, instruction, options = {}) {
|
|
const code = turnCode(turnNumber);
|
|
const marker = turnMarker(turnNumber);
|
|
const startedAt = Date.now();
|
|
const created = await createRunWithOptionalConflict(
|
|
turnNumber,
|
|
buildEditPrompt(turnNumber, instruction),
|
|
{ probeConflict: options.probeConflict },
|
|
);
|
|
|
|
if (options.logoutDuringRun) {
|
|
await logout(`turn ${turnNumber} active`);
|
|
await login(`turn ${turnNumber} resume`);
|
|
}
|
|
|
|
const terminal = await waitForRunTerminal(baseUrl, auth.cookie, created.runId, timeoutMs);
|
|
assert(
|
|
terminal.status === 'succeeded',
|
|
`turn ${turnNumber}: run ${created.runId} ended ${terminal.status}: ${terminal.error_code ?? terminal.error_message ?? ''}`,
|
|
);
|
|
sessionId =
|
|
terminal.agent_session_id
|
|
?? terminal.sessionId
|
|
?? created.sessionId
|
|
?? sessionId;
|
|
assert(sessionId, `turn ${turnNumber}: terminal run has no session id`);
|
|
|
|
const page = await fetchPage();
|
|
const expectedMarkers = [...completedEditCodes.map((entry) => entry.marker), marker];
|
|
for (const expectedMarker of expectedMarkers) {
|
|
assert(
|
|
page.includes(`id="${expectedMarker}"`) || page.includes(`id='${expectedMarker}'`),
|
|
`turn ${turnNumber}: page lost marker ${expectedMarker}`,
|
|
);
|
|
}
|
|
assert(
|
|
!/\b(?:localStorage|sessionStorage|indexedDB)\b/.test(page),
|
|
`turn ${turnNumber}: page introduced forbidden browser storage`,
|
|
);
|
|
const sessionStats = await assertSessionReply(code);
|
|
completedEditCodes.push({ code, marker });
|
|
const record = {
|
|
turnNumber,
|
|
code,
|
|
runId: created.runId,
|
|
sessionId,
|
|
elapsedMs: Date.now() - startedAt,
|
|
pageBytes: Buffer.byteLength(page),
|
|
pageHash: hashText(page),
|
|
...sessionStats,
|
|
};
|
|
runRecords.push(record);
|
|
console.log(
|
|
`[turn ${String(turnNumber).padStart(2, '0')}/21] ${code} ok`
|
|
+ ` run=${created.runId} session=${sessionId}`
|
|
+ ` elapsed=${Math.round(record.elapsedMs / 1000)}s page=${record.pageBytes}B`,
|
|
);
|
|
}
|
|
|
|
async function runStatusTurn(afterTurn, expectedCode) {
|
|
const before = await fetchPage();
|
|
const created = await createAgentRun(baseUrl, auth.cookie, {
|
|
sessionId,
|
|
message: [
|
|
`这是第 ${afterTurn} 轮修改后的状态追问。`,
|
|
`请只汇报 public/${pageName} 当前已完成到 ${turnCode(afterTurn)}，不要修改任何文件。`,
|
|
`最终回复必须包含状态验收码 ${expectedCode} 和页面链接。`,
|
|
].join('\n'),
|
|
});
|
|
const terminal = await waitForRunTerminal(baseUrl, auth.cookie, created.runId, timeoutMs);
|
|
assert(terminal.status === 'succeeded', `${expectedCode}: status run ended ${terminal.status}`);
|
|
sessionId = terminal.agent_session_id ?? terminal.sessionId ?? created.sessionId ?? sessionId;
|
|
const sessionStats = await assertSessionReply(expectedCode);
|
|
const after = await fetchPage();
|
|
assert(
|
|
hashText(after) === hashText(before),
|
|
`${expectedCode}: status-only follow-up unexpectedly changed the page`,
|
|
);
|
|
runRecords.push({
|
|
statusCode: expectedCode,
|
|
runId: created.runId,
|
|
sessionId,
|
|
pageHash: hashText(after),
|
|
...sessionStats,
|
|
});
|
|
console.log(`[status] ${expectedCode} ok; page hash unchanged`);
|
|
}
|
|
|
|
async function main() {
|
|
console.log(`=== Long conversation continuity: ${pageName} ===`);
|
|
await login('initial');
|
|
|
|
for (let index = startTurn - 1; index < editTurns.length; index += 1) {
|
|
const turnNumber = index + 1;
|
|
await runEditTurn(turnNumber, editTurns[index], {
|
|
logoutDuringRun: turnNumber === 13,
|
|
probeConflict: turnNumber === 17,
|
|
});
|
|
|
|
const statusCode = statusAfter.get(turnNumber);
|
|
if (statusCode) await runStatusTurn(turnNumber, statusCode);
|
|
|
|
if (phaseEnds.has(turnNumber)) {
|
|
await logout(`phase after turn ${turnNumber}`);
|
|
await login(`phase after turn ${turnNumber}`);
|
|
}
|
|
}
|
|
|
|
await logout('final persistence check');
|
|
await login('final persistence check');
|
|
const finalPage = await fetchPage();
|
|
const finalTranscript = await assertSessionReply(turnCode(editTurns.length));
|
|
for (const { marker } of completedEditCodes) {
|
|
assert(
|
|
finalPage.includes(`id="${marker}"`) || finalPage.includes(`id='${marker}'`),
|
|
`final page lost ${marker}`,
|
|
);
|
|
}
|
|
assert(
|
|
finalPage.includes('21 轮持续修改验收完成'),
|
|
'final page is missing the 21-turn completion footer',
|
|
);
|
|
await logout('complete');
|
|
|
|
console.log('\n=== RESULT ===');
|
|
console.log(JSON.stringify({
|
|
ok: true,
|
|
startTurn,
|
|
editTurns: completedEditCodes.length,
|
|
statusTurns: runRecords.filter((record) => record.statusCode).length,
|
|
totalConversationTurns: runRecords.length,
|
|
loginCount,
|
|
sessionId,
|
|
pageUrl,
|
|
finalPageBytes: Buffer.byteLength(finalPage),
|
|
finalPageHash: hashText(finalPage),
|
|
finalTranscript,
|
|
runs: runRecords,
|
|
}, null, 2));
|
|
}
|
|
|
|
main().catch(async (error) => {
|
|
console.error(`\nLONG_CONVERSATION_CONTINUITY_FAILED: ${error?.stack ?? error}`);
|
|
if (auth?.cookie) {
|
|
try {
|
|
await logout('failure cleanup');
|
|
} catch (logoutError) {
|
|
console.error(`failure cleanup logout failed: ${logoutError?.message ?? logoutError}`);
|
|
}
|
|
}
|
|
process.exit(1);
|
|
});
|