合入期 5 前置修复 L3:记录页的工件列表把双盲复算对照、反方审稿记录、质询回答归到「核查记录」一组,窄屏下说明换到第二行、序号不被截掉;运行对比的默认基准接口带上 previous,运行详情的对比入口在基准不是紧挨着的上一次时写明「与上一次成功的运行对比」,和触发历史一致

This commit is contained in:
ThearchyHelios
2026-10-06 22:19:25 +08:00
15 changed files with 926 additions and 177 deletions
+316 -53
View File
@@ -11,8 +11,11 @@
// 都不能出现对比页)。下一步的提示要和页面上真能做的事对得上:下拉里没有能换的运行就不叫人去上方换,本次的记录
// 不存在时不给注定失败的「重试」。默认基准的说法照服务端的挑法(api/compare.py 的 pick_base)写「上一次成功的运行」
// ——上一次失败了,基准是再往前成功的那一次;定时任务触发历史里的「与上一次对比」和运行详情里的同名入口打开同一对
// 运行、写同一句来历,基准不是紧挨着的上一次时触发历史上看得见的字写明「上一次成功的运行」;找不到默认基准时标题不说
// 「没有可作为基准的运行」(失败、取消的照样能手动选),换基准的下拉和基准卡写明哪次失败、取消了。
// 运行、写同一句来历,基准不是紧挨着的上一次时两处看得见的字都写明「与上一次成功的运行对比」(运行详情一打开就预先问
// 默认基准,问到之前菜单项不给点,不先写一个叫法再换成另一个;预先问出错、卡着不回时到点不提示,叫法退回、点了照常
// 再问;问到没有默认基准时写「选择基准对比…」,点了直接去对比页手动选;切回这一页时再问一次,问的期间叫法不变);
// 运行详情「工件」页签的悬停写上证据快照、核查记录和节点产出三组;找不到默认基准时
// 标题不说「没有可作为基准的运行」(失败、取消的照样能手动选),换基准的下拉和基准卡写明哪次失败、取消了。
//
// 全部用 page.route 假接口:虚构的「区域销售周报」三次已封存的正式运行和一次没封存的,运行详情、运行列表、
// compare/base、compare、定时任务列表、发起它们的定时任务和触发历史都在浏览器层答掉,别的 GET 放行(外壳要的工作流、
@@ -193,6 +196,13 @@ const FINDING = '正在查找上一次成功的运行'
const NO_OTHER = '同一工作流没有其他可换作基准的已封存运行'
/** 服务端(api/compare.py 的 NO_BASE_TEXT)找不到默认基准时的原话 */
const NO_BASE_SERVER = '没有找到上一次成功的运行:需要同一工作流、同一运行类别里比这次先发起、成功结束并已封存的运行'
/** 运行详情「更多」里对比入口的两种叫法,和触发历史里的链接一致:基准是紧挨着的上一次时、不是时(上一次失败了) */
const MENU = '与上一次对比'
const MENU_LAST_OK = '与上一次成功的运行对比'
/** 预先问到没有默认基准时的叫法:点了直接去只带本次的对比页手动选 */
const MENU_PICK = '选择基准对比…'
/** 预先问默认基准最多等这么久(同 pages/runs/compare/entry.tsx 的 ASK_TIMEOUT_MS),到点按没问到算 */
const ASK_TIMEOUT_MS = 5000
/**
* 发起本次和基准的定时任务(RUNS 里的 schedule_id)和它的触发历史:本次那一行带服务端自动对比的计数,基准是 B、不是
@@ -211,6 +221,11 @@ const FIRES = [{
id: FIRE_T, fire_at: day('10-05'), kind: 'scheduled', status: 'started', run_id: T, run_status: 'succeeded', reason: null,
notified: [], created_at: day('10-05'), compare: { base_run_id: B, previous: false, summary: SUMMARY },
}]
/**
* compare/base 给本次的答复:基准是 B,不是紧挨着的上一次(previous: false),同触发历史那一行的假定。服务端两处用
* 同一个函数挑(api/compare.py 的 pick_base),运行详情「更多」里的入口据此和触发历史写同一个叫法
*/
const BASE_OF_T = { base_run_id: B, reason: 'same_schedule', base: refOf(B), previous: false }
// ---------------------------------------------------------------- 假接口
@@ -234,7 +249,7 @@ const RECORD_GONE = { status: 404, json: { detail: '运行记录不存在' } }
/**
* 默认的假接口。opts.base(runId) / opts.compare(target, base, n) / opts.run(runId, n) / opts.list(workflowId) 可以换掉
* 对应接口的答复(返回 null 的照默认答),返回 {status, json, wait}(wait 是一个 Promise:等它落定再答,用来压住
* 某一次请求)。不在夹具里的运行一律答 404,不放行到服务端
* 某一次请求);opts.fires 换掉触发历史。不在夹具里的运行一律答 404,不放行到服务端
*/
function defaults(opts) {
return async (method, url, n) => {
@@ -251,8 +266,7 @@ function defaults(opts) {
let m = p.match(/^\/api\/runs\/([^/]+)\/compare\/base$/)
if (m) {
if (opts.base) return opts.base(m[1])
return m[1] === T ? { json: { base_run_id: B, reason: 'same_schedule', base: refOf(B) } }
: { status: 404, json: { detail: NO_BASE_SERVER, code: 'compare_no_base' } }
return m[1] === T ? { json: BASE_OF_T } : { status: 404, json: { detail: NO_BASE_SERVER, code: 'compare_no_base' } }
}
m = p.match(/^\/api\/runs\/([^/]+)\/compare$/)
if (m) {
@@ -275,7 +289,7 @@ function defaults(opts) {
if (p === '/api/approvals' && url.searchParams.get('run_id')) return { json: [] }
// 发起本次的定时任务和它的触发历史(只有直接打开那个定时任务的页面时才用到)
if (p === `/api/schedules/${SCHEDULE_ID}`) return { json: SCHEDULE }
if (p === `/api/schedules/${SCHEDULE_ID}/fires`) return { json: { items: FIRES, next_before: null } }
if (p === `/api/schedules/${SCHEDULE_ID}/fires`) return { json: { items: opts.fires ?? FIRES, next_before: null } }
// 查找基准期间离开运行详情去的那一页(定时任务列表):给空的列表,页面落定不靠服务端里有什么
if (p === '/api/schedules') return { json: { items: [] } }
return null
@@ -363,25 +377,39 @@ const shot = async (page, name) => {
// ---------------------------------------------------------------- 检查
/** 运行详情里问了几次默认基准 */
const askedBase = (log, run = T) => log.filter((k) => k === `GET /api/runs/${run}/compare/base`).length
await section('从运行详情进入', async () => {
const { page, log, blocked, errors } = await open(`/runs/${T}`)
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
// 走过的地址(含 pushState / replaceState):菜单要先问到基准再跳,不能先跳到只带本次的地址、再让对比页去找
const visited = []
page.on('framenavigated', (f) => { if (f === page.mainFrame()) visited.push(f.url()) })
await page.getByRole('button', { name: '更多操作' }).click()
const more = page.getByRole('button', { name: '更多操作' })
await more.click()
const item = page.locator('[data-menu=compare]')
check('「更多」菜单里有「与上一次对比」,可点', await item.count() === 1 && (await item.innerText()).includes('与上一次对比')
&& !(await item.isDisabled()))
await until(async () => await item.count() === 1 && !(await item.isDisabled()), 3000)
// 菜单开合几次:叫法已经定了,不再一开菜单就问一遍
await page.keyboard.press('Escape')
await more.click()
await page.waitForTimeout(300)
check('打开运行详情就预先问一次默认基准(定菜单的叫法),菜单开合不再问', askedBase(log) === 1, `${askedBase(log)} 次`)
const label = (await item.innerText()).trim()
check('「更多」菜单里有对比入口,可点;基准不是紧挨着的上一次,写「与上一次成功的运行对比」',
await item.count() === 1 && label === MENU_LAST_OK && !(await item.isDisabled()), label)
const clickAt = log.length
await item.click()
await page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(page)
const url = new URL(page.url())
check('跳到 /runs/compare,带着本次和基准', url.searchParams.get('target') === T && url.searchParams.get('base') === B, url.search)
const iBase = log.indexOf(`GET /api/runs/${T}/compare/base`)
const iCmp = log.indexOf(`GET /api/runs/${T}/compare?base=${B}`)
check('先请求 compare/base,再请求 compare', iBase >= 0 && iCmp > iBase, `${iBase} → ${iCmp}`)
check('compare/base 只请求一次(页面不再自己找一遍)', log.filter((k) => k.startsWith(`GET /api/runs/${T}/compare/base`)).length === 1)
// 点了之后再问一次:详情页可能开了很久,预先问到的基准不一定还是现在的
const after = log.slice(clickAt)
const iBase = after.indexOf(`GET /api/runs/${T}/compare/base`)
const iCmp = after.indexOf(`GET /api/runs/${T}/compare?base=${B}`)
check('点了之后先请求 compare/base,再请求 compare', iBase >= 0 && iCmp > iBase, `${iBase} → ${iCmp}`)
check('点了之后 compare/base 只请求一次(对比页不再自己找一遍)', askedBase(after) === 1, `${askedBase(after)} 次`)
const compareUrls = visited.map((u) => new URL(u)).filter((u) => u.pathname === '/runs/compare')
check('菜单问到基准之后才跳,一步到带基准的地址', compareUrls.length >= 1 && compareUrls.every((u) => u.searchParams.get('base') === B),
compareUrls.map((u) => u.search).join(' → '))
@@ -391,6 +419,22 @@ await section('从运行详情进入', async () => {
check('页面没有报错', errors.length === 0, errors.join(';'))
})
await section('运行详情「工件」页签的悬停:写上证据快照、核查记录和节点产出', async () => {
// 工件页签按证据快照、核查记录、节点产出分三组(pages/runs/ArtifactsPane.tsx),页签头上的悬停是人先看到的那句说明,
// 不能还只写「原始结果和节点产出」。这里顺带查:本脚本本来就用假接口打开真的运行详情
const { page, errors } = await open(`/runs/${T}`)
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
const tab = page.locator(`[data-run-detail="${T}"] [role=tab][data-tab=artifacts]`)
// 工件清单取回来之后悬停里才有件数
const title = await until(async () => {
const t = (await tab.getAttribute('title').catch(() => null)) ?? ''
return /^\d+ 件/.test(t) ? t : null
}, 3000) ?? (await tab.getAttribute('title').catch(() => null)) ?? ''
check('「工件」页签的悬停写上件数和三组:证据快照、核查记录、每个节点的产出', /^\d+ 件/.test(title)
&& ['证据快照', '核查记录', '产出'].every((w) => title.includes(w)), title)
check('页面没有报错', errors.length === 0, errors.join(';'))
})
/** 查找基准期间离开去的那一页:定时任务列表。进去之后不再自己换地址(/data 会再换成 /data/databases),晚到的跳转盖不住 */
const AWAY = '/schedules'
/** 那一页落定:列表读回来了(假接口给的空列表) */
@@ -398,18 +442,20 @@ const awaySettled = (page) => page.locator('[data-schedules-page="list"] [data-s
const NO_BASE = '同一工作流没有其他已封存的正式运行'
/**
* 在运行详情里点「与上一次对比」,compare/base 的答复(answer,默认找到 B)先压住不放。交回页面、放行的函数、这一请求
* 了结的 Promise(答完或者被取消,交回那个请求)、点了之后有没有挂出「正在查找」的提示,和点了之后走过的路径
* (framenavigated 连 pushState、replaceState 都算):晚到的答复哪怕只让页面在对比页一闪而过、又被别的跳转盖掉,
* 在运行详情里点「与上一次对比」,点了之后那一次 compare/base 的答复(answer,默认找到 B)先压住不放;打开详情时预先
* 问的那一次照常答、找到了 B(点了再问时找不到,是这期间基准那一次被删了),菜单项才可点。交回页面、放行的函数、点了
* 之后那一请求了结的 Promise(答完或者被取消,交回那个请求)、点了之后有没有挂出「正在查找」的提示,和点了之后走过的
* 路径(framenavigated 连 pushState、replaceState 都算):晚到的答复哪怕只让页面在对比页一闪而过、又被别的跳转盖掉,
* 走过的路径里也留着
*/
async function findingBase(answer = { json: { base_run_id: B, reason: 'same_schedule', base: refOf(B) } }) {
async function findingBase(answer = { json: BASE_OF_T }) {
let release
const gate = new Promise((r) => { release = r })
const opened_ = await open(`/runs/${T}`, { base: () => ({ ...answer, wait: gate }) })
let clicked = false
const opened_ = await open(`/runs/${T}`, { base: () => (clicked ? { ...answer, wait: gate } : { json: BASE_OF_T }) })
const { page, log } = opened_
const ended = new Promise((resolve) => {
const done = (req) => { if (new URL(req.url()).pathname.endsWith('/compare/base')) resolve(req) }
const done = (req) => { if (clicked && new URL(req.url()).pathname.endsWith('/compare/base')) resolve(req) }
page.on('requestfinished', done)
page.on('requestfailed', done)
})
@@ -417,10 +463,15 @@ async function findingBase(answer = { json: { base_run_id: B, reason: 'same_sche
const visited = []
page.on('framenavigated', (f) => { if (f === page.mainFrame()) visited.push(new URL(f.url()).pathname) })
await page.getByRole('button', { name: '更多操作' }).click()
await page.locator('[data-menu=compare]').click()
const item = page.locator('[data-menu=compare]')
// 预先问的那一次答完,菜单项才可点
await until(async () => !(await item.isDisabled()), 3000)
const asked = askedBase(log)
clicked = true
await item.click()
// 菜单点完就收起了:查找期间要有一条看得见的提示,接口慢的时候不像点了没反应
const noted = await until(async () => await page.locator('[data-toast]', { hasText: FINDING }).count() === 1, 3000)
await until(async () => log.includes(`GET /api/runs/${T}/compare/base`), 3000)
await until(async () => askedBase(log) > asked, 3000)
return { ...opened_, release, ended, noted, visited }
}
@@ -505,19 +556,26 @@ await section('未封存的运行:入口不可点并说明原因', async () =>
}
})
/** 在运行详情里点「更多」→「与上一次对比」,等对比页落定 */
/**
* 在运行详情里点「更多」→ 对比入口,等对比页落定。交回点之前菜单项上看得见的字(预先问到默认基准、可点之后的叫法),
* 和这期间菜单项上出现过的每一种「可点 + 字」(菜单开着时叫法换没换过)
*/
async function viaMenu(page) {
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await page.getByRole('button', { name: '更多操作' }).click()
await page.locator('[data-menu=compare]').click()
const item = page.locator('[data-menu=compare]')
await until(async () => !(await item.isDisabled()), 3000)
const label = (await item.innerText()).trim()
await item.click()
await page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(page)
return label
}
await section('默认基准的说法:上一次成功的运行', async () => {
// 服务端只挑比本次先发起、成功结束并封存的运行:上一次失败、取消了时基准是再往前成功的那一次,「上一次运行」是错的
for (const [reason, want] of [['same_schedule', REASON], ['same_workflow', REASON_WORKFLOW]]) {
const base = () => ({ json: { base_run_id: B, reason, base: refOf(B) } })
const base = () => ({ json: { ...BASE_OF_T, reason } })
const menu = await open(`/runs/${T}`, { base })
await viaMenu(menu.page)
const fromMenu = (await maybeText(menu.page.locator('[data-compare-reason]'))).trim()
@@ -533,31 +591,222 @@ await section('默认基准的说法:上一次成功的运行', async () => {
}
})
await section('运行详情与触发历史的「与上一次对比」:同一个基准、同一句来历', async () => {
// 两处的基准由服务端用同一个函数挑(api/compare.py 的 pick_base):上一次失败了,两处都是再往前成功的 B。两处真的
// 一致由 backend/tests/test_scheduler_compare.py 守,这里守前端两个入口都原样用服务端给的基准
const menu = await open(`/runs/${T}`)
await viaMenu(menu.page)
const hist = await open(`/schedules/${SCHEDULE_ID}?tab=history`)
const link = hist.page.locator(`[data-fire-id="${FIRE_T}"] [data-fire-compare]`)
await link.waitFor({ timeout: 10000 })
const label = (await link.locator('[data-fire-compare-label]').innerText()).trim()
check('触发历史:基准不是紧挨着的上一次,链接上看得见的字写「与上一次成功的运行对比」', label === '与上一次成功的运行对比', label)
await link.click()
await hist.page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(hist.page)
const [a, b] = [new URL(menu.page.url()), new URL(hist.page.url())]
check('两个入口打开的是同一对运行(本次和基准都一样)', a.searchParams.get('target') === T && b.searchParams.get('target') === T
&& a.searchParams.get('base') === B && b.searchParams.get('base') === B, `${a.search} | ${b.search}`)
const [ra, rb] = [(await maybeText(menu.page.locator('[data-compare-reason]'))).trim(),
(await maybeText(hist.page.locator('[data-compare-reason]'))).trim()]
check('两个入口写的默认基准一字不差:同一定时任务上一次成功的运行', ra === REASON && rb === REASON, `${ra} | ${rb}`)
const tiles = (page) => page.locator('[data-compare-summary] [data-compare-class]').evaluateAll((els) =>
els.map((e) => `${e.getAttribute('data-compare-class')}=${e.querySelector('[data-compare-count]')?.textContent?.trim()}`).join(' '))
const [ta, tb] = [await tiles(menu.page), await tiles(hist.page)]
check('两边的变化摘要一致', !!ta && ta === tb, `${ta} | ${tb}`)
check('没有发出写请求', ![...menu.blocked, ...hist.blocked].length, [...menu.blocked, ...hist.blocked].join(';'))
check('页面没有报错', ![...menu.errors, ...hist.errors].length, [...menu.errors, ...hist.errors].join(';'))
await section('运行详情与触发历史的「与上一次对比」:同一个基准、同一个叫法、同一句来历', async () => {
// 两处的基准和 previous 由服务端用同一个函数挑(api/compare.py 的 pick_base):上一次失败了,两处都是再往前成功的 B、
// 都不是紧挨着的上一次。两处真的一致由 backend/tests/test_scheduler_compare.py 守,这里守前端两个入口都原样用服务端
// 给的基准和 previous:看得见的叫法一样,点进去比的是同一对运行
for (const [what, previous, want] of [['上一次失败了', false, MENU_LAST_OK], ['上一次就是成功的', true, MENU]]) {
const base = () => ({ json: { ...BASE_OF_T, previous } })
const fires = FIRES.map((f) => ({ ...f, compare: { ...f.compare, previous } }))
const menu = await open(`/runs/${T}`, { base, fires })
const menuLabel = await viaMenu(menu.page)
const hist = await open(`/schedules/${SCHEDULE_ID}?tab=history`, { base, fires })
const link = hist.page.locator(`[data-fire-id="${FIRE_T}"] [data-fire-compare]`)
await link.waitFor({ timeout: 10000 })
const label = (await link.locator('[data-fire-compare-label]').innerText()).trim()
check(`${what}:运行详情「更多」里的入口和触发历史的链接叫法一致,都写「${want}」`, menuLabel === want && label === want,
`${menuLabel} | ${label}`)
await link.click()
await hist.page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(hist.page)
const [a, b] = [new URL(menu.page.url()), new URL(hist.page.url())]
check(`${what}:两个入口打开的是同一对运行(本次和基准都一样)`, a.searchParams.get('target') === T
&& b.searchParams.get('target') === T && a.searchParams.get('base') === B && b.searchParams.get('base') === B,
`${a.search} | ${b.search}`)
const [ra, rb] = [(await maybeText(menu.page.locator('[data-compare-reason]'))).trim(),
(await maybeText(hist.page.locator('[data-compare-reason]'))).trim()]
check(`${what}:两个入口写的默认基准一字不差:同一定时任务上一次成功的运行`, ra === REASON && rb === REASON, `${ra} | ${rb}`)
const tiles = (page) => page.locator('[data-compare-summary] [data-compare-class]').evaluateAll((els) =>
els.map((e) => `${e.getAttribute('data-compare-class')}=${e.querySelector('[data-compare-count]')?.textContent?.trim()}`).join(' '))
const [ta, tb] = [await tiles(menu.page), await tiles(hist.page)]
check(`${what}:两边的变化摘要一致`, !!ta && ta === tb, `${ta} | ${tb}`)
check(`${what}:没有发出写请求`, ![...menu.blocked, ...hist.blocked].length, [...menu.blocked, ...hist.blocked].join(';'))
check(`${what}:页面没有报错`, ![...menu.errors, ...hist.errors].length, [...menu.errors, ...hist.errors].join(';'))
for (const c of opened) await c.close().catch(() => {})
opened.clear()
}
})
/**
* 菜单项上出现过的每一种状态(可点与否 + 看得见的字),按先后、去掉相邻重复的。挂在页面上,菜单开合、叫法换了都记下:
* 「先写一个叫法、问到了再换成另一个」要从这里看出来
*/
async function watchItem(page) {
await page.evaluate(() => {
const seen = []
window.__compareItem = seen
const look = () => {
const el = document.querySelector('[data-menu=compare]')
if (!el) return
const state = `${el.disabled ? '不可点' : '可点'}:${el.innerText.replace(/\s+/g, ' ').trim()}`
if (seen[seen.length - 1] !== state) seen.push(state)
}
new MutationObserver(look).observe(document.body, { subtree: true, childList: true, characterData: true, attributes: true })
look()
})
return () => page.evaluate(() => window.__compareItem ?? [])
}
await section('菜单的叫法:问到默认基准之前不给点,不先写一个叫法再换成另一个', async () => {
// 预先问的那一次压住:菜单开着时等它,问到之前这一项只写「正在查找」、不给点,问到了直接是最终的叫法
let release
const gate = new Promise((r) => { release = r })
const { page, log, errors } = await open(`/runs/${T}`, { base: () => ({ json: BASE_OF_T, wait: gate }), waitUntil: 'load' })
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await until(async () => askedBase(log) === 1, 3000)
const states = await watchItem(page)
await page.getByRole('button', { name: '更多操作' }).click()
const item = page.locator('[data-menu=compare]')
await item.waitFor()
const waiting = (await item.innerText()).replace(/\s+/g, ' ').trim()
check('问到之前打开菜单:这一项不可点,只写正在查找上一次成功的运行,不先写一个叫法', await item.isDisabled()
&& waiting.startsWith(FINDING) && !waiting.includes(MENU) && !waiting.includes(MENU_LAST_OK), waiting)
release()
await until(async () => !(await item.isDisabled()), 3000)
const label = (await item.innerText()).trim()
check('问到之后:可点,直接是照基准定的叫法(上一次失败了:「与上一次成功的运行对比」)', label === MENU_LAST_OK, label)
// 菜单开着的整个过程:除了「正在查找」,只出现过最终的叫法,而且出现时就可点
const seen = await states()
const named = seen.filter((t) => !t.includes(FINDING))
check('菜单开着的整个过程里叫法没有换过:除了「正在查找」只出现过最终的叫法', named.length === 1
&& named[0] === `可点:${MENU_LAST_OK}`, seen.join(' → '))
check('预先问只问了一次', askedBase(log) === 1, `${askedBase(log)} 次`)
check('页面没有报错', errors.length === 0, errors.join(';'))
})
await section('预先问出错、超时:不提示,叫法退回「与上一次对比」、可点,点了照常再问', async () => {
// 服务端出错:打开详情时不弹报错(人还没点),点了再问一次,这次问到了就照常跳
{
let n = 0
const { page, log, errors } = await open(`/runs/${T}`, { base: () => (++n === 1
? { status: 500, json: { detail: '读取运行记录时出错' } } : { json: BASE_OF_T }) })
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await page.getByRole('button', { name: '更多操作' }).click()
const item = page.locator('[data-menu=compare]')
await until(async () => !(await item.isDisabled()), 3000)
const label = (await item.innerText()).trim()
check('预先问出错:不弹报错,入口可点,叫法退回「与上一次对比」', label === MENU
&& await page.locator('[data-toast]', { hasText: '读取运行记录时出错' }).count() === 0, label)
await item.click()
await page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(page)
check('……点了再问一次,问到了照常跳到对比页', new URL(page.url()).searchParams.get('base') === B && askedBase(log) === 2,
`${page.url()};问了 ${askedBase(log)} 次`)
check('……页面没有报错', errors.length === 0, errors.join(';'))
}
// 连得上却卡着不回(代理、网络卡住):预先问的那一次压住不答。到点按没问到算,入口不能一直停在不可点的「正在查找」
{
let n = 0
let release
const gate = new Promise((r) => { release = r })
// 不等 networkidle:压住的那一次要到点才了结,等它就看不到到点之前的样子了
const { page, log, errors } = await open(`/runs/${T}`, { base: () => (++n === 1 ? { json: BASE_OF_T, wait: gate } : { json: BASE_OF_T }),
waitUntil: 'load' })
try {
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await until(async () => askedBase(log) === 1, 3000)
const states = await watchItem(page)
await page.getByRole('button', { name: '更多操作' }).click()
const item = page.locator('[data-menu=compare]')
await item.waitFor()
const waiting = await item.isDisabled()
const freed = await until(async () => !(await item.isDisabled()), ASK_TIMEOUT_MS + 4000)
const label = (await item.innerText()).trim()
check(`预先问卡着不回:先不可点、写正在查找,${ASK_TIMEOUT_MS / 1000} 秒后按没问到算,入口可点、叫法退回「与上一次对比」`,
waiting && !!freed && label === MENU, `${(await states()).join(' → ')}`)
check('……不弹报错', await page.locator('[data-toast]').count() === 0,
(await page.locator('[data-toast]').allInnerTexts()).join(';'))
await item.click()
await page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(page)
check('……点了再问一次,问到了照常跳到对比页', new URL(page.url()).searchParams.get('base') === B && askedBase(log) === 2,
`${page.url()};问了 ${askedBase(log)} 次`)
check('……页面没有报错', errors.length === 0, errors.join(';'))
} finally {
release()
}
}
})
await section('预先问到没有默认基准:叫法写「选择基准对比…」,点了直接去对比页手动选', async () => {
// 没有默认基准(多为工作流的第一次运行)时还写「与上一次对比」,会让人以为有上一次可比。预先问已经知道没有:叫法照实
// 写,点了不再问一遍、弹提示,直接去只带本次的对比页——那里自己再找一次(这期间有了就用上),找不到写「没有默认基准」,
// 在上方手动选
const { page, log, errors } = await open(`/runs/${T}`, { base: () => ({ status: 404, json: { detail: NO_BASE_SERVER, code: 'compare_no_base' } }) })
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await until(async () => askedBase(log) === 1, 3000)
await page.waitForTimeout(300)
const toast = page.locator('[data-toast]', { hasText: NO_BASE_SERVER })
const quiet = await toast.count() === 0
await page.getByRole('button', { name: '更多操作' }).click()
const item = page.locator('[data-menu=compare]')
await until(async () => !(await item.isDisabled()), 3000)
const label = (await item.innerText()).trim()
check('打开详情时不提示;入口可点,叫法写「选择基准对比…」,不写「与上一次对比」', quiet && label === MENU_PICK, label)
const clickAt = log.length
await item.click()
await page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
await settled(page, 'error')
const u = new URL(page.url())
check('……点了直接去对比页,只带本次,不弹「没有找到上一次成功的运行」的提示', u.searchParams.get('target') === T
&& !u.searchParams.get('base') && await toast.count() === 0, `${u.search};提示 ${await toast.count()} 条`)
const noBase = page.locator('[data-compare-error="no-base"]')
check('……对比页写「没有默认基准」和服务端的原因,下拉可以手动选', await noBase.count() === 1
&& (await noBase.innerText()).includes(NO_BASE_SERVER) && await page.locator('select[data-compare-base-picker]').isEnabled(),
(await maybeText(noBase)).replace(/\s+/g, ' '))
check('……点了之后只有对比页自己找了一次默认基准,菜单没有先问一遍', askedBase(log.slice(clickAt)) === 1,
`点了之后问了 ${askedBase(log.slice(clickAt))} 次`)
check('……页面没有报错', errors.length === 0, errors.join(';'))
})
await section('回到这一页时再问一次默认基准:再问期间叫法不变、可点,问到不一样才换', async () => {
// 详情页可能开了很久,这期间在别处删掉、接着运行完了哪一次,基准跟着变。切去别的标签页、窗口再切回来时再问一次;
// 浏览器切标签页时改 visibilityState、发 visibilitychange,这里照样改、照样发
let answer = { json: { ...BASE_OF_T, previous: true } }
const { page, log, errors } = await open(`/runs/${T}`, { base: () => answer })
const flip = (state) => page.evaluate((s) => {
Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => s })
document.dispatchEvent(new Event('visibilitychange'))
}, state)
await page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
const more = page.getByRole('button', { name: '更多操作' })
const item = page.locator('[data-menu=compare]')
await more.click()
await until(async () => !(await item.isDisabled()), 3000)
const first = (await item.innerText()).trim()
check('先问到的是紧挨着的上一次:写「与上一次对比」', first === MENU, first)
await page.keyboard.press('Escape')
await flip('hidden')
await page.waitForTimeout(300)
check('切走时不问', askedBase(log) === 1, `问了 ${askedBase(log)} 次`)
// 这期间上一次改成了失败的(基准成了再往前的那一次)。再问的那一次压住:菜单开着看,叫法还是原来的、可点
let release
const gate = new Promise((r) => { release = r })
answer = { json: BASE_OF_T, wait: gate }
await flip('visible')
const again = await until(async () => askedBase(log) === 2, 3000)
await more.click()
await item.waitFor()
const during = `${(await item.isDisabled()) ? '不可点' : '可点'}:${(await item.innerText()).trim()}`
check('切回来再问一次;问的期间叫法还是原来的、可点,不退回「正在查找」', again && during === `可点:${MENU}`, during)
const states = await watchItem(page)
release()
const after = await until(async () => ((await item.innerText()).trim() === MENU_LAST_OK ? MENU_LAST_OK : null), 3000)
check('问到不一样了:换成「与上一次成功的运行对比」,照样可点', after === MENU_LAST_OK && !(await item.isDisabled()),
(await states()).join(' → '))
// 再问出错(或者超时):不改已经问到的叫法,也不弹报错
answer = { status: 500, json: { detail: '读取运行记录时出错' } }
await page.keyboard.press('Escape')
await flip('hidden')
await flip('visible')
await until(async () => askedBase(log) === 3, 3000)
await page.waitForTimeout(400)
await more.click()
await item.waitFor()
const kept = `${(await item.isDisabled()) ? '不可点' : '可点'}:${(await item.innerText()).trim()}`
check('再问出错:保留已经问到的叫法、可点,不弹报错', askedBase(log) === 3 && kept === `可点:${MENU_LAST_OK}`
&& await page.locator('[data-toast]', { hasText: '读取运行记录时出错' }).count() === 0, `${kept};问了 ${askedBase(log)} 次`)
check('页面没有报错', errors.length === 0, errors.join(';'))
})
await section('两次运行与摘要', async () => {
@@ -1046,14 +1295,25 @@ await section('出错与找不到基准', async () => {
check('只带本次:自己找到基准、补进地址', new URL(auto.page.url()).searchParams.get('base') === B
&& (await text(auto.page, '[data-compare-reason]')).trim() === REASON)
// 运行详情里找不到基准:提示原因,给「手动选择基准」
const menu = await open(`/runs/${T}`, { base: () => ({ status: 404, json: { detail: '同一工作流没有其他已封存的正式运行' } }) })
// 运行详情里预先问到了基准,点了再问时却找不到(这期间基准那一次被删了):提示原因,给「手动选择基准」;再打开菜单,
// 叫法照这一次的答复写「选择基准对比…」。服务端的 404 不带机读码时也算找不到默认基准(同对比页的 compareErrorKind)
let menuAsks = 0
const menu = await open(`/runs/${T}`, { base: () => (++menuAsks === 1 ? { json: BASE_OF_T }
: { status: 404, json: { detail: '同一工作流没有其他已封存的正式运行' } }) })
await menu.page.locator(`[data-run-detail="${T}"]`).waitFor({ timeout: 10000 })
await menu.page.getByRole('button', { name: '更多操作' }).click()
await menu.page.locator('[data-menu=compare]').click()
const toast = menu.page.locator('[data-toast]', { hasText: '同一工作流没有其他已封存的正式运行' })
check('运行详情里找不到基准:提示原因、留在原页', await until(() => toast.count().then((c) => c === 1))
check('运行详情里点了之后找不到基准:提示原因、留在原页', await until(() => toast.count().then((c) => c === 1))
&& new URL(menu.page.url()).pathname === `/runs/${T}`)
await menu.page.getByRole('button', { name: '更多操作' }).click()
const relabel = await until(async () => {
const t = (await maybeText(menu.page.locator('[data-menu=compare]'))).trim()
return t === MENU_PICK ? t : null
}, 3000)
check('……再打开菜单:叫法照这一次的答复写「选择基准对比…」', relabel === MENU_PICK,
(await maybeText(menu.page.locator('[data-menu=compare]'))).trim())
await menu.page.keyboard.press('Escape')
await toast.getByRole('button', { name: '手动选择基准' }).click()
await menu.page.waitForURL((u) => u.pathname === '/runs/compare', { timeout: 8000 })
check('「手动选择基准」去到对比页,只带本次', new URL(menu.page.url()).searchParams.get('target') === T
@@ -1061,7 +1321,10 @@ await section('出错与找不到基准', async () => {
const none = await open('/runs/compare')
await settled(none.page, 'no-target')
check('什么都没带:说明从哪里进来', (await text(none.page, '[data-compare-page]')).includes('与上一次对比'))
// 说明不逐个列菜单项的叫法(有三种),只说从「更多」菜单打开、默认基准是上一次成功的运行;一句话不超过 40 字
const howTo = (await text(none.page, '[data-compare-page]')).split('\n').map((l) => l.trim()).find((l) => l.includes('「更多」')) ?? ''
check('什么都没带:说明从「更多」菜单打开、默认以上一次成功的运行为基准,不超过 40 字', howTo.includes('上一次成功的运行')
&& [...howTo].length <= 40 && !howTo.includes(`「${MENU}」`), `${[...howTo].length} 字:${howTo}`)
})
await section('基准运行读不到(删了、链接过期)', async () => {
+10 -8
View File
@@ -11,8 +11,8 @@
// 不醒目、409 / 422 不照服务端的中文说明显示(或者问题文字丢了)、Esc 关不掉提问框(或者连带收起了别的、焦点掉到页面上)、
// 已处理的审批和封存了的正式运行还给入口、封存了的探索运行反而没有;同一次运行的几处问答串要对的审批不同、审批列表
// 取不到时后一处一直不列别的审批里问的(头上写着次数,下面一条没有),或者把没能确认的说成「报告其他版本」、不给重试;
// 工件页签里质询的回答只写英文的种类名、截断截在空格上的问题摘要不补省略号、封存后追加的工件给一个跳到运行结束之后的
// 航迹时刻;窄屏(390px)被撑出横向滚动、浅色主题下看不清。
// 工件页签里质询的回答只写英文的种类名、不归在「核查记录」、截断截在空格上的问题摘要不补省略号、悬停里没有整句说明、
// 封存后追加的工件给一个跳到运行结束之后的航迹时刻;窄屏(390px)被撑出横向滚动、浅色主题下看不清。
//
// 跑在预览页上:/preview.html?syn=inquiry-*(用例见 frontend/src/dev/fixtures/inquiry.tsx)。夹具在
// frontend/src/dev/fixtures/inquiry.json,报告文档和回答文档是后端 build_catalog + compose_doc 真实组装的(虚构的数据)。
@@ -835,12 +835,12 @@ await section('运行详情「证据」页签:封存了的探索运行有入
await section('运行详情「工件」页签:质询的回答有名字和说明,不出现英文的工件种类名;封存后追加的不给航迹跳转', async () => {
const { ctx, page, errors } = await open('inquiry-run-artifacts')
await page.locator('[data-run-artifacts] [data-artifact-id]').first().waitFor()
// 每一行:种类(行首的标签)、说明(同一种类有几件时末尾带「#n」,去掉再比)、悬停
// 每一行:种类(行首的标签)、说明(同一种类有几件时的「#n」另在截断范围外,不在说明里)、悬停、分组
const rows = await page.locator('[data-artifact-id]').evaluateAll((els) => els.map((el) => {
const open = el.querySelector('[data-action="artifact-open"]')
const spans = open ? [...open.children] : []
return { id: el.getAttribute('data-artifact-id'), kind: spans[0]?.textContent?.trim() ?? '',
about: (spans[1]?.textContent ?? '').replace(/\s*#\d+$/, '').trim(), title: open?.getAttribute('title') ?? '' }
return { id: el.getAttribute('data-artifact-id'), kind: el.querySelector('[data-artifact-kind-label]')?.textContent?.trim() ?? '',
about: el.querySelector('[data-artifact-about]')?.textContent?.trim() ?? '', title: open?.getAttribute('title') ?? '',
group: el.getAttribute('data-artifact-class') }
}))
const answers = fx.run_artifacts.filter((a) => a.kind === 'inquiry_answer').map((a) => rows.find((r) => r.id === a.id))
check('质询的回答:种类写「质询回答」', answers.length === 4 && answers.every((r) => r?.kind === '质询回答'), JSON.stringify(answers))
@@ -864,7 +864,9 @@ await section('运行详情「工件」页签:质询的回答有名字和说
await page.locator(`[data-artifact-id="${doc.id}"] [data-action="artifact-moment"]`).click()
const jumped = await page.locator('[data-fixture="inquiry-run-artifacts"]').getAttribute('data-fixture-moment')
check('……点报告文档的跳转:到它产出的那一刻', Number(jumped) === Date.parse(`${doc.created_at}Z`), jumped)
check('悬停写「打开质询回答」', answers.every((r) => r?.title.startsWith('打开质询回答')), answers.map((r) => r?.title).join(' / '))
check('悬停写「打开质询回答」,接着是整句说明(行上截断了也看得全)', answers.every((r) => r?.title.startsWith(`打开质询回答:${r.about}`)),
answers.map((r) => r?.title).join(' / '))
check('质询回答归在「核查记录」,不算证据快照', answers.every((r) => r?.group === 'verify'), answers.map((r) => r?.group).join('、'))
const pane = await text(page.locator('[data-run-artifacts]'))
check('工件页签里不出现英文的工件种类名', !/inquiry_answer|report_doc|query_snapshot/.test(pane) && rows.every((r) => !/[a-z_]{4,}/.test(r.kind)),
rows.map((r) => r.kind).join('、'))
@@ -1531,7 +1533,7 @@ await section('窄屏与深浅色', async () => {
const row = `[data-artifact-id="${long.id}"] [data-action="artifact-open"]`
await page.locator(row).waitFor()
const o = await overflow(page, '[data-run-artifacts]')
const ratios = { kind: await ratioOf(page, `${row} > span:nth-child(1)`), about: await ratioOf(page, `${row} > span:nth-child(2)`) }
const ratios = { kind: await ratioOf(page, `${row} [data-artifact-kind-label]`), about: await ratioOf(page, `${row} [data-artifact-about]`) }
check(`390px 工件页签(${theme}):质询回答的长说明截断、不横向溢出,种类和说明对比度 ≥ 4.5`,
o.page <= 0 && o.box <= 0 && ratios.kind >= 4.5 && ratios.about >= 4.5,
JSON.stringify({ o, kind: Number(ratios.kind.toFixed(2)), about: Number(ratios.about.toFixed(2)) }))
+10 -2
View File
@@ -1519,7 +1519,10 @@ await section('详情:触发历史和运行详情的「与上一次对比」
started_at: r.started_at, finished_at: r.finished_at, schedule_id: r.schedule_id })
const compareApi = (method, path, body, url) => {
if (method !== 'GET') return null
if (path === '/runs/run-f10/compare/base') return { json: { base_run_id: 'run-f12', reason: 'same_schedule', base: ref(f12) } }
// previous 同服务端 pick_base:上一次(f11)失败了,基准不是紧挨着的上一次,同触发历史里 f10 那一行(COMPARE_F10)
if (path === '/runs/run-f10/compare/base') {
return { json: { base_run_id: 'run-f12', reason: 'same_schedule', base: ref(f12), previous: COMPARE_F10.previous } }
}
if (path === '/runs/run-f10/compare' && url.searchParams.get('base') === 'run-f12') {
return { json: { target: ref(f10), base: ref(f12), summary: COMPARE_F10.summary, metrics: [], queries: [], notes: [],
template: { base_version: 3, target_version: 3, same_graph: true, nodes: [] } } }
@@ -1536,7 +1539,11 @@ await section('详情:触发历史和运行详情的「与上一次对比」
const menu = await open('/runs/run-f10', { state: stateOf() })
await menu.page.locator('[data-run-detail="run-f10"]').waitFor({ timeout: 10000 })
await menu.page.getByRole('button', { name: '更多操作' }).click()
await menu.page.locator('[data-menu=compare]').click()
// 菜单项等预先问到默认基准才可点,叫法照它的 previous 定
const item = menu.page.locator('[data-menu=compare]')
await until(async () => !(await item.isDisabled().catch(() => true)))
const menuLabel = (await item.innerText().catch(() => '')).trim()
await item.click()
const a = await landed(menu.page)
const hist = await open('/schedules/s-weekly?tab=history', { state: stateOf() })
const link = hist.page.locator('[data-fire-id="f10"] [data-fire-compare]')
@@ -1550,6 +1557,7 @@ await section('详情:触发历史和运行详情的「与上一次对比」
const [ra, rb] = [await reasonOf(menu.page), await reasonOf(hist.page)]
check('……两处写的默认基准一字不差:同一定时任务上一次成功的运行', ra === REASON_SCHEDULE && rb === REASON_SCHEDULE, `${ra} | ${rb}`)
check('……触发历史上看得见的字说明比的是上一次成功的运行', label === '与上一次成功的运行对比', label)
check('……运行详情「更多」里的入口和触发历史的链接叫法一字不差', menuLabel === label, `${menuLabel} | ${label}`)
const tiles = (page) => until(async () => (await page.locator('[data-compare-summary] [data-compare-class]').evaluateAll((els) =>
els.map((e) => `${e.getAttribute('data-compare-class')}=${e.querySelector('[data-compare-count]')?.textContent?.trim()}`))).join(' '))
const [ta, tb] = [await tiles(menu.page), await tiles(hist.page)]
+196 -5
View File
@@ -22,7 +22,10 @@
// 标出,老工件照旧纯文本;
// - 出具缺口:证据页的出具横幅(真的 EvidencePane 里那一个 IssuanceBanner,和问数据、画布右栏同一个)和成果节点印章的
// 悬停说明把双盲复算、反方审稿报上来的缺口另起「核查未通过」「核查未完成」两组,不放在「校验未全部完成」下;
// - 记录页的工件列表:双盲复算对照、反方审稿记录两种工件有名字和说明,不露键名;
// - 记录页的工件列表:双盲复算对照、反方审稿记录两种工件有名字和说明,不露键名;和质询回答一起归在「核查记录」一组,
// 不再算进说明写着「原始结果」的「证据快照」,筛选的件数、悬停说明跟着改(核查、质询时执行的查询仍在证据快照,两组的
// 悬停都写明);390px 窄屏上说明换到第二行(以前挤在一行里只剩三个字),第几件、第几次尝试在截断范围外看得见,悬停
// 写全说明;320px 时校验值和大小不被拆开,每行仍是两行;
// - 检查器:口径卡、指标、口径说明、盲算模型、相对误差、未采用原流程时、启用,每一项都真的写进节点配置;字段的
// 叫法和服务端校验报错里的(engine/labels.py 的 DUAL_CHECK_FIELD_LABEL)一字不差;选口径卡、盲算模型、启用三态用的是
// 和反方审稿共用的控件(verifyFields.tsx);盲算模型不藏在高级选项里
@@ -32,8 +35,8 @@
// - 390px 窄屏不横向溢出,深浅色都读得清,键盘能操作。
//
// 页面都跑在预览页(/preview.html?syn=…,用例在 frontend/src/dev/fixtures/dual_check.tsx,夹具 dual_check.json 两边
// 共用)和设置页上,接口一律 page.route 伪造:完整对照的工件、审批回复、设置的读写都在浏览器里答,别的非 GET 拦掉,
// 不碰真实的写接口。文案对照那一节不开浏览器:读 backend/app/api/settings.py、backend/app/engine/labels.py,terms.ts 借 vite
// 共用;工件页签的用例在 run_artifacts.tsx,工件列表直接交给页签)和设置页上,接口一律 page.route 伪造:完整对照的工件、
// 审批回复、设置的读写都在浏览器里答,别的非 GET 拦掉,不碰真实的写接口。文案对照那一节不开浏览器:读 backend/app/api/settings.py、backend/app/engine/labels.py,terms.ts 借 vite
// 转译后直接 import。
//
// node scripts/check-verify.mjs
@@ -1203,21 +1206,209 @@ await section('记录页的工件列表:双盲复算对照、反方审稿记
const { page, errors } = await preview('dual-check-approval')
const got = await page.evaluate(async () => {
const m = await import('/src/pages/runs/model.ts')
const kinds = ['dual_check', 'challenge', 'inquiry_answer', 'query_snapshot', 'tool_snapshot', 'retrieval_snapshot',
'metric_set', 'metric_input', 'report_doc', 'schema_snapshot', 'node_output', 'some_future_kind']
return {
dual: m.artifactKindLabel('dual_check'), challenge: m.artifactKindLabel('challenge'),
dualDesc: m.artifactDescription('dual_check', { metrics: 2 }), dualBare: m.artifactDescription('dual_check', null),
challengeDesc: m.artifactDescription('challenge', { report: 'report' }),
evidence: m.isEvidence('dual_check') && m.isEvidence('challenge'),
input: m.artifactKindLabel('metric_input'), inputDesc: m.artifactDescription('metric_input', { path: 'vars.region_rows' }),
inputBare: m.artifactDescription('metric_input', null),
groups: Object.fromEntries(kinds.map((k) => [k, m.artifactGroup(k)])),
evidence: Object.fromEntries(kinds.map((k) => [k, m.isEvidence(k)])),
}
})
check('种类:双盲复算对照、反方审稿记录,不露键名', got.dual === '双盲复算对照' && got.challenge === '反方审稿记录', JSON.stringify(got))
check('……说明写清装的是什么:双盲复算带指标个数,没有 meta 的老数据也有一句', got.dualDesc === '双盲复算:2 个指标两边的 SQL、取值与差异说明'
&& got.dualBare === '双盲复算:两边的 SQL、取值与差异说明' && got.challengeDesc === '反方审稿:每句结论的判断、理由和反方执行的查询',
JSON.stringify(got))
check('……两种都算证据(列表里醒目)', got.evidence)
// 核查记录:双盲复算、反方审稿、审批质询对结论的核查与问答。以前算进「证据快照」,那一组的说明写的是「查询、工具调用、
// 知识检索的原始结果」,和装的东西对不上。别的种类的归类不变:核查时执行的查询仍是查询快照,认不出的种类宁可醒目
const want = { dual_check: 'verify', challenge: 'verify', inquiry_answer: 'verify', node_output: 'output' }
const wrong = Object.entries(got.groups).filter(([k, g]) => g !== (want[k] ?? 'evidence'))
check('……双盲复算对照、反方审稿记录、质询回答归在「核查记录」;查询、工具、检索的快照,口径卡、报告文档、表结构仍是证据快照',
wrong.length === 0, JSON.stringify(wrong))
check('……isEvidence 只认证据快照这一组', Object.entries(got.evidence).every(([k, v]) => v === ((want[k] ?? 'evidence') === 'evidence')),
JSON.stringify(got.evidence))
check('……口径卡里容器型变量输入的完整值(metric_input)也有名字和说明,不露键名', got.input === '指标输入'
&& got.inputDesc === '口径卡输入「vars.region_rows」的完整值' && got.inputBare === '口径卡输入的完整值', JSON.stringify(got))
check('……页面没有报错', errors.length === 0, errors.join(';'))
})
/** 工件页签里每一行:种类、说明、第几件、悬停、分组,和种类标签、说明、第几件、时刻各自的位置 */
const artifactRows = (page) => page.locator('[data-run-artifacts] [data-artifact-id]').evaluateAll((els) => els.map((el) => {
const rect = (n) => {
if (!n) return null
const r = n.getBoundingClientRect()
return { left: r.left, right: r.right, top: r.top, bottom: r.bottom, width: r.width }
}
const box = (sel) => rect(el.querySelector(sel))
const about = el.querySelector('[data-artifact-about]')
return {
id: el.getAttribute('data-artifact-id'), group: el.getAttribute('data-artifact-class'),
kind: el.querySelector('[data-artifact-kind-label]')?.textContent?.trim() ?? '',
about: about?.textContent?.trim() ?? '', nth: el.querySelector('[data-artifact-nth]')?.textContent?.trim() ?? '',
title: el.querySelector('[data-action="artifact-open"]')?.getAttribute('title') ?? '',
// 说明看得见的宽度、是否被截断(scrollWidth 比看得见的宽)
visible: about ? Math.round(about.getBoundingClientRect().width) : 0, cut: about ? about.scrollWidth > about.clientWidth + 1 : false,
row: rect(el), chip: box('[data-artifact-kind-label]'), line: box('[data-artifact-about-line]'),
nthBox: box('[data-artifact-nth]'), hash: box('[title^="内容校验值"]'), size: box('[data-artifact-size]'),
when: box('[data-action="artifact-moment"]') ?? box('[data-artifact-time]'),
}
}))
await section('记录页的工件页签:核查记录单独一组,筛选的件数和说明跟着改', async () => {
// 夹具(frontend/src/dev/fixtures/run_artifacts.tsx):22 件,证据快照 10 件(查询快照 6、表结构、指标输入、口径卡、
// 报告文档),核查记录 4 件(双盲复算对照、反方审稿记录、两条质询回答),节点产出 8 件
const { page, errors } = await preview('run-artifacts')
await page.locator('[data-run-artifacts] [data-artifact-id]').first().waitFor()
const filters = await page.locator('[data-run-artifacts] [data-artifact-kind]').evaluateAll((els) => els.map((el) => ({
key: el.getAttribute('data-artifact-kind'), text: el.textContent.replace(/\s+/g, ' ').trim(), title: el.getAttribute('title') ?? '',
})))
check('筛选:全部、证据快照、核查记录、节点产出四档,件数对得上', JSON.stringify(filters.map((f) => f.text))
=== JSON.stringify(['全部 22', '证据快照 10', '核查记录 4', '节点产出 8']), filters.map((f) => f.text).join('、'))
const hint = Object.fromEntries(filters.map((f) => [f.key, f.title]))
// 归类按种类:双盲复算、反方审稿、审批质询执行的查询仍是查询快照,归在证据快照(夹具里 6 件查询快照有 4 件是这样来的)。
// 两组的悬停都得说清,证据快照不能说成「结论里的数字从这里来」,核查记录要指明其间执行的查询在哪一组
check('「核查记录」的悬停说清装的是双盲复算对照、反方审稿记录、质询回答,其间执行的查询见「证据快照」',
['双盲复算对照', '反方审稿记录', '质询回答', '「证据快照」'].every((w) => hint.verify?.includes(w)), hint.verify)
check('「证据快照」的悬停:原始结果之外写上口径卡、报告文档、表结构,并点明含核查、质询时执行的查询,不说结论的数字都从这里来',
['查询', '口径卡', '报告文档', '表结构', '核查', '质询', '执行的查询'].every((w) => hint.evidence?.includes(w))
&& !(hint.evidence ?? '').includes('结论里的数字'), hint.evidence)
const long = Object.entries(hint).filter(([, t]) => [...(t ?? '')].length > 45)
check('三组的悬停都在 45 字以内(用语规范:说明约 40 字)', long.length === 0,
long.map(([k, t]) => `${k} ${[...t].length} 字`).join('、'))
const all = await artifactRows(page)
check('「全部」列出 22 件,每件都标了分组', all.length === 22 && all.every((r) => ['evidence', 'verify', 'output'].includes(r.group)),
`${all.length} 件`)
check('种类都是中文,不露键名(metric_input 写「指标输入」)', all.every((r) => r.kind && !/[a-z_]{4,}/.test(r.kind)),
[...new Set(all.map((r) => r.kind))].join('、'))
await page.locator('[data-run-artifacts] [data-artifact-kind="verify"]').click()
const verify = await artifactRows(page)
check('点「核查记录」:只剩双盲复算对照、反方审稿记录、质询回答 4 件', verify.length === 4 && verify.every((r) => r.group === 'verify')
&& JSON.stringify([...new Set(verify.map((r) => r.kind))].sort()) === JSON.stringify(['双盲复算对照', '反方审稿记录', '质询回答'].sort()),
verify.map((r) => r.kind).join('、'))
check('……按节点分组:双盲复算、反方审稿各一组,质询回答在「不属于某个节点」', JSON.stringify(await page.locator('[data-run-artifacts] [data-artifact-group]')
.evaluateAll((els) => els.map((e) => e.getAttribute('data-artifact-group')))) === JSON.stringify(['dual', 'review', '']))
await page.locator('[data-run-artifacts] [data-artifact-kind="evidence"]').click()
const evidence = await artifactRows(page)
check('点「证据快照」:10 件,没有核查记录混在里面(核查时执行的查询快照照旧在这里)', evidence.length === 10
&& evidence.every((r) => r.group === 'evidence') && !evidence.some((r) => /双盲复算对照|反方审稿记录|质询回答/.test(r.kind))
&& evidence.filter((r) => r.kind === '查询快照').length === 6, evidence.map((r) => r.kind).join('、'))
await page.locator('[data-run-artifacts] [data-artifact-kind="output"]').click()
const output = await artifactRows(page)
check('点「节点产出」:8 件,都是节点产出', output.length === 8 && output.every((r) => r.group === 'output' && r.kind === '节点产出'),
output.map((r) => r.kind).join('、'))
await page.locator('[data-run-artifacts] [data-artifact-kind="all"]').click()
// 宽屏一行排下:说明和种类在同一行,第几件紧跟说明
const wide = await artifactRows(page)
const looped = wide.filter((r) => r.nth)
check('宽屏(1280):说明和种类在同一行', wide.every((r) => r.line && r.chip && Math.abs(r.line.top - r.chip.top) < 8),
JSON.stringify(wide.filter((r) => !(r.line && r.chip && Math.abs(r.line.top - r.chip.top) < 8)).map((r) => r.kind)))
check('宽屏:逐区汇总的三次产出编了号,重试的那次写明第 2 次尝试', JSON.stringify(looped.filter((r) => r.kind === '节点产出').map((r) => r.nth))
=== JSON.stringify(['#1', '#2 · 第 2 次尝试', '#3']), looped.map((r) => `${r.kind}${r.nth}`).join('、'))
check('宽屏:短的说明不截断', wide.filter((r) => [...r.about].length <= 20).every((r) => !r.cut),
wide.filter((r) => [...r.about].length <= 20 && r.cut).map((r) => r.about).join('、'))
check('悬停写全说明(打开哪一种、装的是什么、第几件)', wide.every((r) => r.title.startsWith(`打开${r.kind}:${r.about}`)
&& (!r.nth || r.title.includes(r.nth))), wide.find((r) => !r.title.startsWith(`打开${r.kind}:${r.about}`))?.title)
check('页面没有报错', errors.length === 0, errors.join(';'))
})
await section('记录页的工件页签:390px、320px 说明换到第二行,第几件在截断范围外,不横向溢出、深浅色可读', async () => {
for (const theme of ['dark', 'light']) {
const { page, errors } = await preview('run-artifacts', { width: 390, height: 844, theme })
await page.locator('[data-run-artifacts] [data-artifact-id]').first().waitFor()
const rows = await artifactRows(page)
const o = await page.evaluate(() => {
const doc = document.documentElement
const pane = document.querySelector('[data-run-artifacts]')
const scroller = pane?.querySelector('.overflow-y-auto')
return { page: doc.scrollWidth - doc.clientWidth, pane: pane ? pane.scrollWidth - pane.clientWidth : -1,
list: scroller ? scroller.scrollWidth - scroller.clientWidth : -1 }
})
check(`390px(${theme}):页签不横向溢出`, o.page <= 0 && o.pane <= 0 && o.list <= 0, JSON.stringify(o))
// 说明在种类下面另起一行;以前和种类、校验值、大小、时刻挤在一行,只剩三个字宽(约 35px)
const below = rows.filter((r) => r.line && r.chip && r.line.top >= r.chip.bottom - 1)
check(`390px(${theme}):每一行的说明都换到种类下面的第二行`, below.length === rows.length,
rows.filter((r) => !below.includes(r)).map((r) => r.kind).join('、'))
const widths = rows.map((r) => r.visible)
const narrowest = rows.filter((r) => r.cut).reduce((m, r) => Math.min(m, r.visible), Infinity)
check(`390px(${theme}):说明看得见的宽度:被截断的至少 200px,其余整句看得全`,
rows.every((r) => !r.cut || r.visible >= 200), `截断的最窄 ${narrowest === Infinity ? '—' : `${narrowest}px`};各行 ${widths.join('/')}`)
const long = rows.find((r) => r.kind === '质询回答' && r.about.endsWith('…」的回答'))
check(`390px(${theme}):长问题的质询回答截断了,悬停里是整句说明`, !!long && long.cut && long.title.includes(long.about),
long ? `${long.visible}px · ${long.title}` : '没找到长问题的那一条')
// 第几件:放在截断范围外,整个落在这一行里、看得见
const numbered = rows.filter((r) => r.nth)
check(`390px(${theme}):第几件、第几次尝试都看得见(不在被截断的说明里,不出这一行)`, numbered.length >= 5
&& numbered.every((r) => r.nthBox && r.nthBox.width > 0 && r.nthBox.right <= r.row.right + 0.5 && r.nthBox.left >= r.row.left),
numbered.map((r) => `${r.kind}${r.nth}`).join('、'))
// 第一行:种类、校验值、大小,时刻(或时间)和它们在同一行
check(`390px(${theme}):时刻(或时间)留在第一行,和种类对齐`, rows.every((r) => r.when && r.chip
&& Math.abs((r.when.top + r.when.bottom) / 2 - (r.chip.top + r.chip.bottom) / 2) <= 4),
JSON.stringify(rows.filter((r) => !(r.when && r.chip && Math.abs((r.when.top + r.when.bottom) / 2 - (r.chip.top + r.chip.bottom) / 2) <= 4))
.map((r) => [r.kind, r.when, r.chip]).slice(0, 2)))
check(`390px(${theme}):内容校验值还在第一行`, rows.every((r) => r.hash && r.chip && r.hash.bottom <= r.line.top + 1))
const c = await page.evaluate(() => {
const base = getComputedStyle(document.body).backgroundColor
const pick = (sel) => {
const el = document.querySelector(sel)
if (!el) return null
let bg = 'rgba(0, 0, 0, 0)'
for (let n = el; n && n !== document.documentElement; n = n.parentElement) {
const v = getComputedStyle(n).backgroundColor
if (v !== 'rgba(0, 0, 0, 0)' && v !== 'transparent') { bg = v; break }
}
return { fg: getComputedStyle(el).color, bg }
}
return { base, kind: pick('[data-artifact-class="verify"] [data-artifact-kind-label]'),
about: pick('[data-artifact-class="verify"] [data-artifact-about]'), nth: pick('[data-artifact-nth]'),
filter: pick('[data-artifact-kind="verify"]') }
})
for (const key of ['kind', 'about', 'nth', 'filter']) {
const v = c[key]
const ratio = v ? contrast(v.fg, v.bg, c.base) : 0
check(`${theme}:${({ kind: '种类', about: '说明', nth: '第几件', filter: '「核查记录」筛选' })[key]}对比度 ≥ 4.5`, ratio >= 4.5,
`${ratio.toFixed(2)}(${v?.fg} on ${v?.bg})`)
}
const bar = await page.locator('[data-run-artifacts] [data-artifact-kind]').evaluateAll((els) =>
els.every((el) => { const r = el.getBoundingClientRect(); return r.left >= 0 && r.right <= innerWidth && r.width > 0 }))
check(`390px(${theme}):四个筛选按钮都在屏幕里`, bar)
await shot(page, `run-artifacts-narrow-${theme}`)
check(`390px(${theme}):页面没有报错`, errors.length === 0, errors.join(';'))
}
// 再窄(320px 的小屏手机):第一行放不下种类、校验值、大小时,以前大小单独折到种类下面、校验值留在右边,行成了三行。
// 校验值和大小一起排;这一栏窄于 22rem 时收起校验值(打开后的查看器里写着),每行仍是两行:种类、大小、时刻在第一行,
// 说明在第二行
{
const { page, errors } = await preview('run-artifacts', { width: 320, height: 720, theme: 'dark' })
await page.locator('[data-run-artifacts] [data-artifact-id]').first().waitFor()
const rows = await artifactRows(page)
const o = await page.evaluate(() => {
const doc = document.documentElement
const scroller = document.querySelector('[data-run-artifacts] .overflow-y-auto')
return { page: doc.scrollWidth - doc.clientWidth, list: scroller ? scroller.scrollWidth - scroller.clientWidth : -1 }
})
check('320px:页签不横向溢出', o.page <= 0 && o.list <= 0, JSON.stringify(o))
const mid = (b) => (b.top + b.bottom) / 2
const split = rows.filter((r) => !(r.size && r.chip && r.size.width > 0 && Math.abs(mid(r.size) - mid(r.chip)) <= 4))
check('320px:大小留在第一行、和种类对齐,不单独折到种类下面', split.length === 0,
split.map((r) => `${r.kind}(大小 ${JSON.stringify(r.size)},种类 ${JSON.stringify(r.chip)})`).slice(0, 3).join(';'))
const apart = rows.filter((r) => r.hash && r.hash.width > 0 && r.size && Math.abs(mid(r.hash) - mid(r.size)) > 4)
check('320px:校验值和大小不被拆开(收起,或者同在一行)', apart.length === 0, apart.map((r) => r.kind).join('、'))
const below = rows.filter((r) => r.line && r.chip && r.line.top >= r.chip.bottom - 1)
check('320px:说明在种类下面的第二行', below.length === rows.length, rows.filter((r) => !below.includes(r)).map((r) => r.kind).join('、'))
const narrowest = rows.filter((r) => r.cut).reduce((m, r) => Math.min(m, r.visible), Infinity)
check('320px:被截断的说明看得见的宽度至少 150px', rows.every((r) => !r.cut || r.visible >= 150),
`截断的最窄 ${narrowest === Infinity ? '—' : `${narrowest}px`}`)
await shot(page, 'run-artifacts-320-dark')
check('320px:页面没有报错', errors.length === 0, errors.join(';'))
}
const wide = await preview('run-artifacts', { width: 1280, height: 900, theme: 'light' })
await wide.page.locator('[data-run-artifacts] [data-artifact-id]').first().waitFor()
await shot(wide.page, 'run-artifacts-wide-light')
})
// ---------------------------------------------------------------- 检查器与节点卡片
/**