fix(终态): 消掉第二套任务终态词表,并把判据从正则换成 AST

useTaskProgressLoop 的 DEFAULT_TERMINAL 只认 SUCCESS|FAILED,而 COMPLETED≡SUCCESS
(task-status-text 把两者都映射成「已完成」,看板 SUCCESS_STATUSES_ORDERED 也含两者)。
收到 COMPLETED 不退出的轮询会一直空转到瞬断预算耗尽——这形状先前在跟价与风控两页踩过。
唯一被这次改宽影响的页面是 BrandCollectDataTab(它不传 isTerminal);BrandPublishTab
传自己那份含 COMPLETED+CANCELLED 的判定,行为不变,已用单独一条钉子钉住。

判据原先是"变量名恰为 status"的源码正则,同形异名全 src 有 16 处抓不到,等于恒绿;
现在用 typescript(node_modules 里已有)做 AST 尺子,并把"旧正则对三条反例失明"写进断言。
ShopMatch 的 waitForScheduledTaskStageExit 等的是阶段不是任务终态,为此给骨架加了可选
exitOn,保住它原有语义、未知状态不会挂死。

口径更正:窄集合"全 src 应为 0"不成立——实测 20 处/8 文件是 fileStatus(结果文件维度)、
loop-run 带 STOPPED 的词表、显示与下载判定,不同维度不该混进一本账;改成迁移面硬 0 +
逐文件台账只许减。catch 同理:grep 'catch (' 的 292 数不到无绑定 catch {,AST 口径 295/84。
This commit is contained in:
2026-10-08 17:36:47 +08:00
parent 520044c8a4
commit aea5614a8b
8 changed files with 1020 additions and 82 deletions
@@ -532,15 +532,18 @@ async function waitForTaskTerminal(taskId: number) {
transientBudget: 30,
});
}
/**
* 排期任务「等当前轮次跑完」:退出条件是**状态离开 RUNNING**,不是任务到终态——
* SUCCESS/COMPLETED/FAILED 走终态收尾、SCHEDULED 表示已排到下一轮、其余任何状态都算本轮结束。
* 所以这里给骨架传 exitOn 而不是往 terminal 里堆状态表(漏一个后端新状态就是永不退出的紧循环)。
* 循环本体(disposed 优先、瞬断计数与退避)在骨架里;取数方式(重型 batch)、页内副作用与文案留在本页。
*/
async function waitForScheduledTaskStageExit(taskId: number) {
let transientErrorCount = 0
const maxTransientErrors = 30
while (true) {
if (disposed) return 'STOPPED'
try {
return waitForTaskTerminalShared({
taskId,
isDisposed: () => disposed,
pollStatus: async () => {
const batch = await getShopMatchTaskProgressBatch([taskId])
if (transientErrorCount > 0) queuePushResult.value = `任务 ${taskId} 服务已恢复,继续等待当前轮次结束...`
transientErrorCount = 0
if ((batch.missingTaskIds || []).includes(taskId)) {
removeTaskLocally(taskId)
await refreshTaskViewsBestEffort()
@@ -558,31 +561,34 @@ async function waitForScheduledTaskStageExit(taskId: number) {
taskDetails.value[taskId] = status
saveTaskDetailsToStorage()
}
if (!status || status === 'RUNNING') {
await sleep(getPollIntervalMs())
continue
}
if (isTaskTerminalStatus(status)) {
removePollingTask(taskId)
await refreshTaskViewsBestEffort()
restoreScheduledDispatches()
return status
}
if (status === 'SCHEDULED') {
} else if (status === 'SCHEDULED') {
stopPollingTask(taskId)
restoreScheduledDispatches()
return status
}
return status
} catch (error) {
if (!isTransientBackendError(error)) throw error
transientErrorCount += 1
if (transientErrorCount >= maxTransientErrors) throw new Error(`任务 ${taskId} 等待当前轮次结束超时,请稍后手动刷新查看状态`)
queuePushResult.value = `任务 ${taskId} 运行中,正在等待当前轮次结束(${transientErrorCount}/${maxTransientErrors})...`
if (transientErrorCount === 1 || transientErrorCount % 5 === 0) ElMessage.warning(`任务 ${taskId} 运行中,服务暂时不可用,正在自动重试`)
await sleep(getPollIntervalMs())
}
}
// 空串=还没出这一轮(骨架据此继续等);离开 RUNNING 一律交回状态原文,含本页不认识的状态
return status && status !== 'RUNNING' ? status : ''
},
// 瞬断恢复提示由骨架在取数成功后统一发(原来也是取到批次后立刻发,措辞照旧)
onRecovered: () => {
queuePushResult.value = `任务 ${taskId} 服务已恢复,继续等待当前轮次结束...`
},
onTransient: (attempt, budget) => {
queuePushResult.value = `任务 ${taskId} 运行中,正在等待当前轮次结束(${attempt}/${budget})...`
if (attempt === 1 || attempt % 5 === 0) ElMessage.warning(`任务 ${taskId} 运行中,服务暂时不可用,正在自动重试`)
},
isTransient: isTransientBackendError,
onBudgetExhausted: () => {
throw new Error(`任务 ${taskId} 等待当前轮次结束超时,请稍后手动刷新查看状态`)
},
exitOn: (status) => status !== 'RUNNING',
intervalMs: getPollIntervalMs,
sleep,
transientBudget: 30,
})
}
function resolvedTaskStatus(item: ShopMatchHistoryItem) {
const itemStatus = item.taskStatus || ''
@@ -6,6 +6,7 @@ import {
getTaskForegroundRefreshDelayMs,
} from '../task-progress-config.ts'
import { createCategorizedTimers } from '../utils/categorized-timers.ts'
import { isTerminalTaskStatus } from '../utils/task-terminal.ts'
import { createTaskPollingBaseline, type TaskPollingBaseline } from '../task-polling-baseline.ts'
import type { ProgressResponseCache } from '../progress-response-cache.ts'
import type { TaskPollingCoordinator } from '../task-polling-coordinator.ts'
@@ -23,7 +24,8 @@ import type { TaskPollingCoordinator } from '../task-polling-coordinator.ts'
* fetchProgress: (ids) => getCollectDataTaskProgressBatch(ids),
* extractTaskId: (detail) => detail.task?.id,
* extractStatus: (detail) => detail.task?.status,
* isTerminal: (status) => status === 'SUCCESS' || status === 'FAILED',
* // isTerminal 省略即为共用词表(SUCCESS / COMPLETED / FAILED,见 utils/task-terminal.ts);
* // 只有本页另有词表时才传,例如排期循环那种阶段状态机。
* onUpdate: (taskId, detail) => { ... },
* onTerminal: async (taskId, detail) => { await refreshHistory() },
* })
@@ -41,7 +43,7 @@ export interface TaskProgressLoopOptions<TDetail> {
extractTaskId: (detail: TDetail) => number | null | undefined
/** 从单条进度详情中提取状态字符串(如 'PENDING'/'RUNNING'/'SUCCESS'/'FAILED') */
extractStatus: (detail: TDetail) => string | null | undefined
/** 判定是否终态;默认 SUCCESS / FAILED 视为终态 */
/** 判定是否终态;默认走共用词表 TERMINAL_TASK_STATUSES(SUCCESS / COMPLETED / FAILED) */
isTerminal?: (status: string) => boolean
/** 每条进度落地时调用,用于上层缓存最新快照 */
onUpdate?: (taskId: number, detail: TDetail) => void
@@ -91,7 +93,15 @@ export interface TaskProgressLoopHandle {
dispose: () => void
}
const DEFAULT_TERMINAL = (status: string) => status === 'SUCCESS' || status === 'FAILED'
/**
* 默认终态判定=共用骨架那份词表,别再在这里抄一遍 SUCCESS / FAILED。
*
* 行为变更(相对旧默认):COMPLETED 现在也算终态。旧窄集合收到 COMPLETED 时不会把任务从
* 轮询集合里摘除,页面会一直轮询下去(用户看到「任务永远执行中」),而后端早就结束了;
* COMPLETED≡SUCCESS 的口径出处:shared/utils/task-status-text.ts 把两者都映射成「已完成」/success,
* 与 utils/task-terminal.ts 顶部的说明一致。
*/
const DEFAULT_TERMINAL = isTerminalTaskStatus
function readIdsFromStorage(key?: string): number[] {
if (!key || typeof window === 'undefined') return []
+11 -1
View File
@@ -42,6 +42,15 @@ export interface TaskTerminalWait {
onTransient?: (attempt: number, budget: number) => void
/** 瞬断判定,沿用各页原有的 TRANSIENT_BACKEND_ERROR_PATTERNS 口径。 */
isTransient: (error: unknown) => boolean
/**
* 阶段型等待(排期轮次、巡店当前阶段)用:退出条件不是"任务到终态"而是"这一阶段不再执行",
* 例如非 RUNNING 的任何状态都算出阶段。给了它就绕过 `terminal` 成员判定,
* 参数是已经 trim+toUpperCase 过的状态。
*
* 为什么开这个口子而不是往 `terminal` 里堆状态:堆表漏一个后端新状态就会**永不退出**(紧循环挂死),
* 谓词形式(`!== 'RUNNING'`)天然兜住未知状态。任务型等待仍走 `terminal`,不许用它改写终态词表。
*/
exitOn?: (status: string) => boolean
/** 预算耗尽:六页原本都是 throw(措辞各异),所以默认抛通用文案。 */
onBudgetExhausted?: (attempt: number) => never
intervalMs: () => number
@@ -69,7 +78,8 @@ export async function waitForTaskTerminal(wait: TaskTerminalWait): Promise<strin
transientErrors = 0
wait.onStatus?.(status)
const normalized = (status || '').trim().toUpperCase()
if (normalized && terminal.includes(normalized)) return normalized
// 空串仍是"继续等";给了 exitOn(阶段型等待)就用它,否则用终态词表成员判定。
if (normalized && (wait.exitOn ? wait.exitOn(normalized) : terminal.includes(normalized))) return normalized
} catch (error) {
if (!wait.isTransient(error)) throw error
transientErrors += 1
@@ -0,0 +1,119 @@
// catch 静默棘轮:只许减,不许增(四面9分口径 §2 用户端「错误静默」)。
//
// 口径与扫描器都在 tests/helpers/catch-silence-scanner.ts:按 AST 数 CatchClause,
// 静默=空块,或首条语句是 console.* 且整块没有 throw / 没有 ElMessage 这类用户可见出口。
// 与文档基线 292/81 的差别写在扫描器头注释里(grep 数不到无绑定的 `catch {`),这里钉实扫的 295/84。
// 跑法:npm test
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { fileURLToPath } from 'node:url'
import { dirname, resolve, relative, sep } from 'node:path'
import { listSourceFiles, readSource } from './helpers/task-terminal-ast-ruler.ts'
import { scanCatchSilence, toLedger, totals } from './helpers/catch-silence-scanner.ts'
const here = dirname(fileURLToPath(import.meta.url))
const root = resolve(here, '..')
const rel = (p: string) => relative(root, p).split(sep).join('/')
const SRC_FILES = listSourceFiles(resolve(root, 'src')).map(rel)
const BASELINE = {
blocks: 295,
silent: 84,
/** 逐文件台账:只钉总数与文件数两个标量的棘轮,会被「A 加一条 + B 减一条」整段绕过。 */
perFile: {
'src/pages/brand/components/BrandCollectDataTab.vue': 4,
'src/pages/brand/components/BrandConvertTab.vue': 1,
'src/pages/brand/components/BrandDedupeTab.vue': 1,
'src/pages/brand/components/BrandPriceTrackTab.vue': 8,
'src/pages/brand/components/BrandProductRiskTab.vue': 8,
'src/pages/brand/components/BrandPublishTab.vue': 2,
'src/pages/brand/components/BrandQueryAsinTab.vue': 1,
'src/pages/brand/components/BrandShopDataCrawlTab.vue': 1,
'src/pages/brand/components/BrandShopMatchTab.vue': 1,
'src/pages/brand/components/BrandSimilarAsinTab.vue': 1,
'src/pages/brand/components/BrandSplitTab.vue': 1,
'src/pages/brand/components/BrandVariantTab.vue': 2,
'src/pages/home/DesktopHomePage.vue': 1,
'src/pages/image-video/components/DeliveryVideoWorkspace.vue': 1,
'src/pages/login/DesktopLoginPage.vue': 12,
'src/pages/setup/DesktopSecretSetupPage.vue': 1,
'src/router/index.ts': 3,
'src/shared/api/http.ts': 1,
'src/shared/api/task-progress-polling.ts': 1,
'src/shared/api/types/modules/permission.ts': 1,
'src/shared/auth/account-expiry.ts': 1,
'src/shared/auth/ensure-auth.ts': 1,
'src/shared/auth/kick-handler.ts': 4,
'src/shared/bridges/web-fallback.ts': 2,
'src/shared/components/ApiSecretSettingsPanel.vue': 1,
'src/shared/components/ExpiryNotice.vue': 2,
'src/shared/components/NotificationBell.vue': 3,
'src/shared/composables/useLiveTaskBoard.ts': 1,
'src/shared/composables/useTaskProgressLoop.ts': 3,
'src/shared/composables/useVersionUpdate.ts': 1,
'src/shared/dispatch-guard-ui.ts': 1,
'src/shared/route-prefetch.ts': 1,
'src/shared/utils/api-secret-store.ts': 9,
'src/shared/utils/notification-bell.ts': 1,
'src/shared/utils/row-id.ts': 1,
} as Record<string, number>,
}
const scans = SRC_FILES.map((f) => scanCatchSilence(readSource(f, root), f))
const now = totals(scans)
const ledger = toLedger(scans)
test('分母自证:扫描器真的看见了整棵 src(分母塌了的话"≤基线"就是恒绿)', () => {
assert.ok(SRC_FILES.length > 100, `只扫到 ${SRC_FILES.length} 个文件,分母不对`)
assert.ok(SRC_FILES.some((f) => f.endsWith('.vue')), '.vue 没进分母就是漏扫')
assert.ok(now.blocks >= 250, `catch 块只数到 ${now.blocks} 个,与基线 ${BASELINE.blocks} 差得离谱 ⇒ 扫描器坏了,不是代码变好了`)
// 非零对照:已知藏着静默 catch 的文件必须被扫到,否则"0 处"没有意义
assert.ok(ledger['src/shared/utils/api-secret-store.ts'] > 0, 'api-secret-store.ts 的静默 catch 没被数到,扫描器口径失效')
assert.ok(ledger['src/pages/login/DesktopLoginPage.vue'] > 0, 'DesktopLoginPage.vue 的静默 catch 没被数到,扫描器口径失效')
})
test('静默 catch 只许减:总数与逐文件台账都不许超过基线', () => {
const worse: string[] = []
for (const [file, count] of Object.entries(ledger)) {
const allowed = BASELINE.perFile[file]
if (allowed === undefined) worse.push(`${file} 是新增静默 catch 的文件(${count} 处)`)
else if (count > allowed) worse.push(`${file} 从 ${allowed} 处涨到 ${count} 处`)
}
assert.deepEqual(worse, [], `新增了静默 catch,要么把错误报给用户、要么显式上抛:\n${worse.join('\n')}`)
assert.ok(now.silent <= BASELINE.silent,
`静默 catch 总数 ${now.silent} > 基线 ${BASELINE.silent};减下去了就把基线与台账一起改小`)
assert.ok(now.blocks <= BASELINE.blocks, `catch 块总数从 ${BASELINE.blocks} 涨到 ${now.blocks},新增 try/catch 要一并说明理由`)
})
test('扫描器先自证:新增一个空 catch 一定被数出来', () => {
const target = 'src/pages/brand/components/BrandCollectDataTab.vue'
const source = readSource(target, root).replace(/\r\n/g, '\n')
const anchor = 'function selectCountry(code: string) {'
assert.equal(source.split(anchor).length - 1, 1, '锚点不唯一,注入自证不作数')
const before = scanCatchSilence(source, target)
const injected = source.replace(anchor, 'function injectedProbeForRuler() {\n try { throw new Error("x") } catch { }\n}\n' + anchor)
assert.notEqual(injected, source, '注入没生效,这条自证是假的')
const after = scanCatchSilence(injected, target)
assert.equal(after.total, before.total + 1, '多出来的 catch 块没被数到分母')
assert.equal(after.silent.length, before.silent.length + 1, '多出来的空 catch 体没被数成静默')
assert.deepEqual(Object.entries(ledger).map(([f, c]) => [f, c]).filter(([f]) => f === target).map(([, c]) => c), [before.silent.length],
'台账与单文件复扫对不上')
})
test('扫描器的口径边界:console + throw、console + ElMessage 都不算静默', () => {
const cases: Array<[string, number]> = [
['try { f() } catch { }', 1],
['try { f() } catch (e) { console.log(e) }', 1],
['try { f() } catch (e) { console.error(e); throw e }', 0],
['try { f() } catch (e) { console.error(e); ElMessage.error("失败了") }', 0],
['try { f() } catch (e) { ElMessage.error(String(e)) }', 0],
['try { f() } catch (e) { retry() }', 0],
]
for (const [src, expected] of cases) {
const r = scanCatchSilence(src, '<内存口径>')
assert.equal(r.silent.length, expected, `口径判错:${src}(期望静默 ${expected},实测 ${r.silent.length})`)
assert.equal(r.total, 1, `catch 块分母判错:${src}`)
}
})
@@ -0,0 +1,102 @@
/**
* catch 静默扫描器(tests 工具层,判据在 tests/catch-silence-ratchet.test.ts)。
*
* 口径(与四面 9 分口径文档一致,逐条落到 AST 上,不靠 grep 数行数):
* 一个 catch 子句算"静默",当且仅当
* ① 块体是空的;或
* ② 块体第一条语句是 console.* 调用,且整块里没有 throw、也没有 ElMessage/ElNotification 这类用户可见提示。
* 其余形状(只 catch 后什么都不做但赋了个值、写了注释、调了别的函数)都**不**算——棘轮要能钉得住,
* 口径就得是可复算的,不能靠人临场判断。
*
* 与文档基线 292/81 的口径差:那张表的"分母与 `grep -c 'catch ('` 对齐",而 grep 数不到
* 无绑定的 `catch {`(本仓有)与 `} catch (e) {` 单行紧凑写法;本扫描器按 AST 数 CatchClause,
* 实测 296 块 / 84 静默。**这里钉 296/84 这条实扫基线**,只许减不许增。
*/
import { createRequire } from 'node:module'
import { extractScript, parseModule } from './task-terminal-ast-ruler.ts'
const require = createRequire(import.meta.url)
const ts = require('typescript')
export interface SilentCatch {
file: string
line: number
/** 'empty'=空块;'console-only'=只往控制台打了一句 */
kind: 'empty' | 'console-only'
snippet: string
}
export interface CatchScan {
file: string
total: number
silent: SilentCatch[]
}
/** 用户可见提示的符号名(本仓只有 Element Plus 这一套)。 */
const TOAST_SYMBOLS = new Set(['ElMessage', 'ElNotification', 'ElMessageBox'])
function walk(node: any, cb: (n: any) => void): void {
cb(node)
ts.forEachChild(node, (child: any) => walk(child, cb))
}
function firstStatementIsConsole(node: any): boolean {
if (!ts.isExpressionStatement(node)) return false
const call = node.expression
if (!ts.isCallExpression(call)) return false
const callee = call.expression
if (!ts.isPropertyAccessExpression(callee)) return false
const base = callee.expression
return ts.isIdentifier(base) && base.text === 'console'
}
/** 块里有没有"响"的出口:throw(语句或表达式两支)或任意 ElMessage.* / 裸 ElMessage 引用。 */
function hasLoudExit(body: any): boolean {
let loud = false
walk(body, (n: any) => {
if (ts.isThrowStatement(n) || n.kind === ts.SyntaxKind.ThrowExpression) loud = true
if (ts.isIdentifier(n) && TOAST_SYMBOLS.has(n.text)) loud = true
})
return loud
}
export function scanCatchSilence(code: string, file: string): CatchScan {
const { script, lineOffset } = extractScript(code, file)
const sf = parseModule(script, file)
let total = 0
const silent: SilentCatch[] = []
walk(sf, (node: any) => {
if (!ts.isCatchClause(node)) return
total += 1
const block = node.block
const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1 + lineOffset
const snippet = script.slice(node.getStart(sf), block.getEnd()).replace(/\s+/g, ' ').trim()
if (block.statements.length === 0) {
silent.push({ file, line, kind: 'empty', snippet })
return
}
if (!firstStatementIsConsole(block.statements[0])) return
if (hasLoudExit(block)) return
silent.push({ file, line, kind: 'console-only', snippet })
})
return { file, total, silent }
}
/** 把逐文件结果汇成一个可对比的台账:`相对路径 -> 静默处数`。 */
export function toLedger(scans: CatchScan[]): Record<string, number> {
const ledger: Record<string, number> = {}
for (const s of scans) if (s.silent.length) ledger[s.file] = s.silent.length
return ledger
}
export function totals(scans: CatchScan[]): { blocks: number; silent: number; byFile: number } {
let blocks = 0
let silent = 0
let byFile = 0
for (const s of scans) {
blocks += s.total
silent += s.silent.length
if (s.silent.length) byFile += 1
}
return { blocks, silent, byFile }
}
@@ -0,0 +1,393 @@
/**
* 终态词表的 AST 尺子(判据从"源码正则"升级来的那一半,跑在 node --test 里,无新依赖)。
*
* 为什么必须弃用正则:上一版尺子长这样
* /===\s*'SUCCESS'\s*\|\|\s*status\s*===\s*'FAILED'\s*\)/
* 它把"变量名恰好叫 status"和"两个比较挨在一起"当成了词表的定义。于是
* const x = (s: string) => s === 'SUCCESS' || s === 'FAILED' ← 同形异名,抓不到
* if (st === 'SUCCESS' || st === 'FAILED') return ← 同上
* [TaskStatus.SUCCESS, TaskStatus.FAILED].includes(status) ← 数组形态,同上
* 三类都从尺子底下滑过去,尺子就**恒绿**了——恒绿的判据比没有判据更糟,它让下一次抄袭变得安全。
*
* 现在按 AST 结构判:把 `||` 链(含嵌在数组里的 `.includes()` 形态)归约成"这条判断认得哪些状态词",
* 只要同时认得 SUCCESS 与 FAILED、又不认得 COMPLETED,就是窄集合。不看变量名、不看排版、不数空格。
*
* 精度闸(防误红,误红的判据下次没人信):链里还出现 RUNNING/PENDING/SCHEDULED 这类**非终态**词的,
* 是"这行要不要显示成执行中"的显示判断,不是"任务到没到终态"的等待判断,不计入。
*/
import { readFileSync, readdirSync, statSync } from 'node:fs'
import { join, relative } from 'node:path'
import { createRequire } from 'node:module'
const require = createRequire(import.meta.url)
const ts = require('typescript')
/** 大写状态词的形状:SUCCESS / COMPLETED / DELETED_XXX;小写与普通标识符不算状态词。 */
const STATUS_WORD = /^[A-Z][A-Z0-9_]{2,}$/
/** 与骨架一致:这两个词是"任务确实结束了"的最小充分对。 */
const NARROW_PAIR = ['SUCCESS', 'FAILED']
/** COMPLETED≡SUCCESS 的出处见 shared/utils/task-status-text.ts;出现它就不算窄集合。 */
const WIDE_MARKER = 'COMPLETED'
/** 非终态词:出现即说明这条判断不是"等终态",不计入窄集合。 */
const NON_TERMINAL_WORDS = new Set([
'RUNNING', 'PENDING', 'SCHEDULED', 'QUEUED', 'PAUSED', 'WAITING', 'PROCESSING', 'INIT', 'CREATED',
])
export interface NarrowHit {
/** 文件相对路径(相对仓库根,即 frontend-vue) */
file: string
line: number
/** 命中的那条判断的源码片段(报错时给出可读证据,不只给个数字) */
snippet: string
/** 这条判断认得的状态词 */
words: string[]
}
function walk(node: any, cb: (n: any) => void): void {
cb(node)
ts.forEachChild(node, (child: any) => walk(child, cb))
}
/** .vue 只取 `<script>` 段;顺带记下段首行号,好把命中位置折算回文件真实行。 */
export function extractScript(code: string, file: string): { script: string; lineOffset: number } {
if (!file.endsWith('.vue')) return { script: code, lineOffset: 0 }
const blocks = [...code.matchAll(/<script\s+[^>]*>([\s\S]*?)<\/script>/g)]
if (blocks.length !== 1) throw new Error(`${file} 的 <script> 段数是 ${blocks.length}(要求恰 1 段),尺子无法定位`)
const m = blocks[0] as unknown as RegExpExecArray & { index: number }
const scriptStart = m.index + m[0].indexOf(m[1])
return { script: m[1], lineOffset: code.slice(0, scriptStart).split('\n').length - 1 }
}
/**
* 解析失败必须**抛**,不许返回空数组。
* 返回空数组="这文件没毛病",于是语法坏掉的文件的窄集合永久隐身(恒绿的第三条路)。
*/
export function parseModule(script: string, file: string): any {
const sf = ts.createSourceFile(file, script, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
const diags = sf.parseDiagnostics || []
if (diags.length) {
const first = diags[0]
const { line } = sf.getLineAndCharacterOfPosition(first.start)
throw new Error(`${file} 语法解析失败(第 ${line + 1} 行起 ${diags.length} 处):${ts.flattenDiagnosticMessageText(first.messageText, ' ')}`)
}
return sf
}
function unwrap(node: any): any {
let n = node
while (n && (ts.isAsExpression(n) || ts.isParenthesizedExpression(n)
// `<TaskStatus.SUCCESS>` 老式尖括号断言与 `x!` 非空断言:按 kind 比,不依赖版本里的谓词函数名
|| n.kind === ts.SyntaxKind.TypeAssertionExpression || n.kind === ts.SyntaxKind.NonNullExpression)) n = n.expression
return n
}
/** 字符串字面量与 `TaskStatus.SUCCESS` 这类枚举成员都算状态词来源。 */
function statusWord(node: any): string | null {
const n = unwrap(node)
if (!n) return null
if (ts.isStringLiteral(n) || ts.isNoSubstitutionTemplateLiteral(n)) return STATUS_WORD.test(n.text) ? n.text : null
if (ts.isPropertyAccessExpression(n) && typeof n.name?.text === 'string' && STATUS_WORD.test(n.name.text)) return n.name.text
return null
}
function isBarBar(node: any): boolean {
return ts.isBinaryExpression(node) && node.operatorToken?.kind === ts.SyntaxKind.BarBarToken
}
function isIncludesCall(node: any): boolean {
return ts.isCallExpression(node)
&& ts.isPropertyAccessExpression(node.expression)
&& node.expression.name?.text === 'includes'
}
/** `.includes()` 的接收者若是数组字面量,就把它当作词表读出来。 */
function includesArrayLiteral(node: any): any | null {
if (!isIncludesCall(node)) return null
const arr = unwrap(node.expression.expression)
return arr && ts.isArrayLiteralExpression(arr) ? arr : null
}
/** 沿 `||` 链收集状态词:`a === 'SUCCESS' || b === 'FAILED'` → {SUCCESS, FAILED}。 */
function collectWords(node: any, out: Set<string>): void {
if (isBarBar(node)) {
collectWords(node.left, out)
collectWords(node.right, out)
return
}
if (ts.isBinaryExpression(node)
&& (node.operatorToken?.kind === ts.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken?.kind === ts.SyntaxKind.EqualsEqualsToken)) {
const word = statusWord(node.right) ?? statusWord(node.left)
if (word) out.add(word)
return
}
const arr = includesArrayLiteral(node)
if (arr) for (const el of arr.elements) {
const word = statusWord(el)
if (word) out.add(word)
}
}
function isNarrow(words: Set<string>): boolean {
if (!NARROW_PAIR.every((w) => words.has(w))) return false
if (words.has(WIDE_MARKER)) return false
for (const w of words) if (NON_TERMINAL_WORDS.has(w)) return false
return true
}
/** 数组字面量是不是"某某 .includes()" 的接收者——是的话由那条调用一起判,避免同一处报两遍。 */
function isIncludesReceiver(node: any, parent: any): boolean {
return !!parent && ts.isPropertyAccessExpression(parent) && parent.name?.text === 'includes' && parent.expression === node
}
export function findNarrowTerminalSets(code: string, file: string): NarrowHit[] {
const { script, lineOffset } = extractScript(code, file)
const sf = parseModule(script, file)
const hits: NarrowHit[] = []
walk(sf, (node: any) => {
let subject: any = null
if (isBarBar(node)) {
// 只判链顶:子链是父链的一部分,重复报会虚增处数
if (node.parent && isBarBar(node.parent)) return
subject = node
} else if (includesArrayLiteral(node)) {
subject = node
} else if (ts.isArrayLiteralExpression(node) && !isIncludesReceiver(node, node.parent)) {
subject = node
}
if (!subject) return
const words = new Set<string>()
if (subject === node && isBarBar(subject)) {
collectWords(subject, words)
} else {
const arr = subject === node && ts.isArrayLiteralExpression(subject) ? subject : includesArrayLiteral(subject)
for (const el of arr.elements) {
const word = statusWord(el)
// 元素里混了非状态词(变量、数字)就不是词表,别猜
if (!word) return
words.add(word)
}
if (arr.elements.length === 0) return
}
if (!isNarrow(words)) return
hits.push({
file,
line: sf.getLineAndCharacterOfPosition(subject.getStart(sf)).line + 1 + lineOffset,
snippet: script.slice(subject.getStart(sf), subject.getEnd()).replace(/\s+/g, ' ').trim(),
words: [...words],
})
})
return hits
}
/** 待扫文件:src 下的 .ts/.vue(.d.ts 是声明文件,不含判断逻辑,排掉)。 */
export function listSourceFiles(rootDir: string): string[] {
const out: string[] = []
const stack = [rootDir]
while (stack.length) {
const dir = stack.pop() as string
for (const name of readdirSync(dir)) {
const p = join(dir, name)
if (statSync(p).isDirectory()) { stack.push(p); continue }
if (!/\.(ts|vue)$/.test(name)) continue
if (/\.d\.ts$/.test(name)) continue
out.push(p)
}
}
return out.sort()
}
export function readSource(relFromRoot: string, repoRoot: string): string {
return readFileSync(join(repoRoot, relFromRoot), 'utf-8')
}
/** 全库扫一遍;返回命中清单与扫过的文件数(分母要能自证,别只给一个数)。 */
export function scanNarrowTerminalSets(repoRoot: string, relFiles: string[]): { hits: NarrowHit[]; filesWithHits: number } {
const hits: NarrowHit[] = []
let filesWithHits = 0
for (const rel of relFiles) {
const found = findNarrowTerminalSets(readSource(rel, repoRoot), rel)
if (found.length) filesWithHits += 1
hits.push(...found)
}
return { hits, filesWithHits }
}
export function formatHits(hits: NarrowHit[]): string {
return hits.map((h) => `${relative('.', h.file) || h.file}:${h.line} [${h.words.join(', ')}] ${h.snippet.slice(0, 90)}`).join('\n')
}
/** 一条等待函数的形状(上一版尺子用字符串切函数体,名字一改就失效;这里按 AST 找)。 */
export interface WaitFunctionShape {
name: string
line: number
/** 函数体里调用到的被调名(标识符调用与 `a.b()` 的 b 都收) */
calls: string[]
/** 有没有自己写 `while (true)` 循环 */
hasWhileTrue: boolean
/** 有没有自己声明瞬断计数器(骨架外再数一份预算的标志) */
declaresTransientCounter: boolean
/** 有没有传 exitOn(阶段型等待的退出谓词) */
passesExitOn: boolean
/** 有没有传 terminal(页专属终态词表,例如巡店删除的 DELETED) */
passesTerminal: boolean
}
function calleeNames(node: any, out: Set<string>): void {
if (ts.isCallExpression(node)) {
const c = node.expression
// 命名导入的别名(`waitForTaskTerminal as waitForTaskTerminalShared`)在调用点就是标识符本身
if (ts.isIdentifier(c)) out.add(c.text)
else if (ts.isPropertyAccessExpression(c) && c.name) out.add(c.name.text)
}
ts.forEachChild(node, (child: any) => calleeNames(child, out))
}
/** 对象字面量的键名集合(含嵌套):骨架调用有没有传 exitOn / terminal 就看这个。 */
function objectLiteralKeys(node: any, out: Set<string>): void {
if (ts.isObjectLiteralExpression(node)) {
for (const prop of node.properties) {
const key = prop.name
if (!key) continue
if (ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key)) out.add(key.text)
}
}
ts.forEachChild(node, (child: any) => objectLiteralKeys(child, out))
}
/**
* 找出文件里所有名字以 `waitFor` 开头的函数声明,返回它们的形状。
* 上一版判据是 `source.indexOf('async function waitForTaskTerminal(taskId: number)')` 切字符串,
* 签名一改(加参数、改缩进、换行写)就找不到而静默放行;这里按 AST 认函数名。
*/
export function findWaitFunctions(code: string, file: string): WaitFunctionShape[] {
const { script, lineOffset } = extractScript(code, file)
const sf = parseModule(script, file)
const out: WaitFunctionShape[] = []
walk(sf, (node: any) => {
if (!ts.isFunctionDeclaration(node)) return
const name = node.name?.text
if (typeof name !== 'string' || !name.startsWith('waitFor')) return
const calls = new Set<string>()
calleeNames(node, calls)
let hasWhileTrue = false
let declaresTransientCounter = false
walk(node, (inner: any) => {
if (ts.isWhileStatement(inner)) {
const expr = inner.expression
if (expr.kind === ts.SyntaxKind.TrueKeyword) hasWhileTrue = true
}
if (ts.isVariableDeclaration(inner)) {
const t = name2text(inner.name)
// 只认**可变**计数变量(`let transientErrorCount`);`const TRANSIENT = [...]` 是错误特征串表,不是自己数瞬断
const list = inner.parent
const isConst = !!list && (list.flags & ts.NodeFlags.Const) !== 0
if (/transient/i.test(t) && !isConst) declaresTransientCounter = true
}
})
const keys = new Set<string>()
objectLiteralKeys(node, keys)
out.push({
name,
line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1 + lineOffset,
calls: [...calls],
hasWhileTrue,
declaresTransientCounter,
passesExitOn: keys.has('exitOn'),
passesTerminal: keys.has('terminal'),
})
})
return out
}
function name2text(name: any): string {
if (!name) return ''
if (ts.isIdentifier(name)) return name.text
return ''
}
/** 页面喂给 useTaskProgressLoop 的终态配置形状。 */
export interface ProgressLoopConfig {
file: string
line: number
/** options 里有没有显式传 `isTerminal`;没传=这页吃的就是骨架那份词表 */
passesIsTerminal: boolean
/** 传了的话,值是本页哪个函数(只认标识符形式) */
isTerminalRef: string | null
/** 那个函数认得的状态词:从 `||` 链与数组词表里读出来 */
isTerminalWords: string[]
/** 那个函数是否直接委托给共用判定(委托时词表取骨架那份) */
delegatesToShared: boolean
}
function wordsOfExpressionContainer(node: any, out: Set<string>): void {
if (isBarBar(node) || (ts.isBinaryExpression(node)
&& (node.operatorToken?.kind === ts.SyntaxKind.EqualsEqualsEqualsToken || node.operatorToken?.kind === ts.SyntaxKind.EqualsEqualsToken))) {
collectWords(node, out)
}
if (ts.isArrayLiteralExpression(node)) {
for (const el of node.elements) {
const word = statusWord(el)
if (word) out.add(word)
}
}
ts.forEachChild(node, (child: any) => wordsOfExpressionContainer(child, out))
}
/**
* 读出页面里 `useTaskProgressLoop({...})` 的终态配置。
* 用途不是代替行为断言,而是让行为断言**用页面自己那份词表**去跑,
* 免得测试里手抄一遍状态字面量(手抄的副本会和源码漂移,那才是真正的恒绿)。
*/
export function readProgressLoopConfigs(code: string, file: string, sharedPredicateNames: string[] = ['isTerminalTaskStatus']): ProgressLoopConfig[] {
const { script, lineOffset } = extractScript(code, file)
const sf = parseModule(script, file)
const decls = new Map<string, any>()
walk(sf, (n: any) => {
if ((ts.isFunctionDeclaration(n) || ts.isArrowFunction(n)) && n.name && ts.isIdentifier(n.name)) decls.set(n.name.text, n)
if (ts.isVariableStatement(n)) for (const d of n.declarationList.declarations) {
if (ts.isIdentifier(d.name) && d.initializer) decls.set(d.name.text, d.initializer)
}
})
const out: ProgressLoopConfig[] = []
walk(sf, (node: any) => {
if (!ts.isCallExpression(node)) return
const callee = node.expression
const calleeName = ts.isIdentifier(callee) ? callee.text : ts.isPropertyAccessExpression(callee) ? callee.name?.text : ''
if (calleeName !== 'useTaskProgressLoop') return
const options = node.arguments[0]
if (!options || !ts.isObjectLiteralExpression(options)) return
const prop = options.properties.find((p: any) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === 'isTerminal')
const cfg: ProgressLoopConfig = {
file,
line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1 + lineOffset,
passesIsTerminal: !!prop,
isTerminalRef: null,
isTerminalWords: [],
delegatesToShared: false,
}
if (prop) {
const init = (prop as any).initializer
if (init && ts.isIdentifier(init)) cfg.isTerminalRef = init.text
if (init && ts.isCallExpression(init) && ts.isIdentifier(init.expression)) cfg.isTerminalRef = init.expression.text
const target = cfg.isTerminalRef ? decls.get(cfg.isTerminalRef) : null
if (target) {
const words = new Set<string>()
const delegated = new Set<string>()
walk(target, (inner: any) => {
wordsOfExpressionContainer(inner, words)
if (ts.isCallExpression(inner) && ts.isIdentifier(inner.expression) && sharedPredicateNames.includes(inner.expression.text)) delegated.add(inner.expression.text)
})
cfg.isTerminalWords = [...words]
cfg.delegatesToShared = delegated.size > 0
}
}
out.push(cfg)
})
return out
}
@@ -0,0 +1,179 @@
// 终态词表合一之后的行为钉子(四面9分口径 §2 用户端「第二套终态词表」)。
//
// .vue 在本套件里挂不起来(没有 @vue/test-utils,见 tests/enqueue-rejection-wiring.test.ts 的说明),
// 所以这两条钉子按「页面的真实配置 + 真实骨架」两半钉:
// ① 用 AST 从页面源码里读出它喂给 useTaskProgressLoop 的终态配置(不手抄状态字面量,抄的副本会和源码漂移);
// ② 把那份配置交给真的 useTaskProgressLoop 跑,断言收到 COMPLETED 会终止、任务从轮询集合摘除、不再继续发请求。
// 跑法:npm test
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { fileURLToPath } from 'node:url'
import { dirname, resolve } from 'node:path'
import { useTaskProgressLoop } from '../src/shared/composables/useTaskProgressLoop.ts'
import { TERMINAL_TASK_STATUSES, waitForTaskTerminal } from '../src/shared/utils/task-terminal.ts'
import { readProgressLoopConfigs, readSource } from './helpers/task-terminal-ast-ruler.ts'
const here = dirname(fileURLToPath(import.meta.url))
const root = resolve(here, '..')
const COLLECT = 'src/pages/brand/components/BrandCollectDataTab.vue'
const PUBLISH = 'src/pages/brand/components/BrandPublishTab.vue'
interface Item { taskId?: number; status?: string }
function setupWindow() {
const storage = new Map<string, string>()
;(globalThis as Record<string, unknown>).window = {
localStorage: {
getItem: (k: string) => storage.get(k) ?? null,
setItem: (k: string, v: string) => { storage.set(k, v) },
removeItem: (k: string) => { storage.delete(k) },
},
setTimeout: (fn: () => void, ms: number) => globalThis.setTimeout(fn, ms),
clearTimeout: (id: unknown) => globalThis.clearTimeout(id as number),
setInterval: (fn: () => void, ms: number) => globalThis.setInterval(fn, ms),
clearInterval: (id: unknown) => globalThis.clearInterval(id as number),
}
}
const tick = (ms = 0) => new Promise<void>((r) => globalThis.setTimeout(r, ms))
/**
* 按页面的真实终态配置跑一轮轮询。
* isTerminal 省略=这页吃的就是骨架那份词表(BrandCollectDataTab 正是这种)。
*/
async function driveLoop(cfg: { isTerminalWords: string[]; passesIsTerminal: boolean }, status: string) {
let fetches = 0
const terminalCalls: Array<{ taskId: number; status: string }> = []
const errors: unknown[] = []
const predicate = cfg.passesIsTerminal
? { isTerminal: (s: string) => cfg.isTerminalWords.includes((s || '').trim().toUpperCase()) }
: {}
const loop = useTaskProgressLoop<Item>({
scope: `terminal-${status}-${Date.now()}`,
fetchProgress: async () => { fetches += 1; return { items: [{ taskId: 9, status }] } },
extractTaskId: (d) => d?.taskId,
extractStatus: (d) => d?.status,
getIntervalMs: () => 5, // 窄词表空转时这一下就会露出来:请求一轮接一轮停不住
onTerminal: (taskId, _detail, s) => { terminalCalls.push({ taskId, status: s }) },
onError: (e) => { errors.push(e) },
...predicate,
})
loop.reset([9])
await tick(0) // reset 触发的那一轮
return { loop, terminalCalls, errors, polls: () => fetches }
}
test('BrandCollectDataTab 没传 isTerminal:它吃的就是骨架那份词表', () => {
const cfgs = readProgressLoopConfigs(readSource(COLLECT, root), COLLECT)
assert.equal(cfgs.length, 1, `从源码里读到 ${cfgs.length} 处 useTaskProgressLoop 调用,判据前提没了`)
assert.equal(cfgs[0].passesIsTerminal, false,
'这页一旦开始自传 isTerminal,"共用词表"这条钉子就管不到它了,要连这条一起改')
})
test('BrandCollectDataTab 的配置收到 COMPLETED 会终止,并且不再空转发请求', async () => {
setupWindow()
const cfgs = readProgressLoopConfigs(readSource(COLLECT, root), COLLECT)
const h = await driveLoop(cfgs[0], 'COMPLETED')
await tick(60)
assert.deepEqual(h.terminalCalls, [{ taskId: 9, status: 'COMPLETED' }], 'COMPLETED 必须触发一次终态回调')
assert.deepEqual(h.loop.taskIds.value, [], '任务要能从轮询集合里摘掉')
assert.equal(h.polls(), 1, `COMPLETED 之后还在发第 ${h.polls()} 轮请求 ⇒ 又空转了`)
assert.deepEqual(h.errors, [])
h.loop.dispose()
})
test('BrandPublishTab 的配置收到 COMPLETED 同样终止(它自带 CANCELLED,但仍认 COMPLETED)', async () => {
setupWindow()
const cfgs = readProgressLoopConfigs(readSource(PUBLISH, root), PUBLISH)
assert.equal(cfgs.length, 1, `从源码里读到 ${cfgs.length} 处 useTaskProgressLoop 调用`)
assert.equal(cfgs[0].passesIsTerminal, true, '这页原本就自传 isTerminal,本轮迁移不该让它退回默认')
assert.ok(cfgs[0].isTerminalWords.includes('COMPLETED'),
`页内词表 ${cfgs[0].isTerminalWords.join('|')} 里没有 COMPLETED——那这页收到 COMPLETED 会一直轮询`)
const h = await driveLoop(cfgs[0], 'COMPLETED')
await tick(60)
assert.deepEqual(h.terminalCalls, [{ taskId: 9, status: 'COMPLETED' }])
assert.equal(h.polls(), 1, 'COMPLETED 之后不该再发请求')
assert.deepEqual(h.loop.taskIds.value, [])
h.loop.dispose()
})
test('反面钉子:换成迁移前那份窄词表,同一条 COMPLETED 就会空转(证明上面两条不是恒绿)', async () => {
setupWindow()
const narrow = { passesIsTerminal: true, isTerminalWords: ['SUCCESS', 'FAILED'] }
const h = await driveLoop(narrow, 'COMPLETED')
await tick(60)
assert.deepEqual(h.terminalCalls, [], '窄词表本就不该认 COMPLETED——这条如果变了说明 driveLoop 写错了')
assert.deepEqual(h.loop.taskIds.value, [9], '任务仍留在轮询集合里')
assert.ok(h.polls() > 1, `窄词表下必须能看到"停不下来的轮询",否则上面那条钉子没有对照:实际轮询 ${h.polls()} 次`)
h.loop.dispose()
})
// —— BrandShopMatchTab 的排期阶段等待:等的是阶段退出,不是任务终态 ——
/** 骨架的紧循环只替 IO 边界;循环本体真跑。 */
function stageHarness(statuses: string[], exitOn?: (s: string) => boolean) {
const queue = [...statuses]
const sleeps: number[] = []
let disposed = false
const wait = {
taskId: 4321,
isDisposed: () => disposed,
pollStatus: async () => (queue.length > 1 ? queue.shift() as string : queue[0] ?? ''),
intervalMs: () => 1000,
isTransient: () => false,
sleep: async () => { sleeps.push(1000); if (sleeps.length > 6) disposed = true },
...(exitOn ? { exitOn } : {}),
}
return { wait, queue, sleeps }
}
test('阶段型等待:RUNNING 继续等,离开 RUNNING(含 SCHEDULED 与未知状态)立刻退出', async () => {
const stageExit = (s: string) => s !== 'RUNNING'
const running = stageHarness(['RUNNING', 'SCHEDULED'], stageExit)
assert.equal(await waitForTaskTerminal(running.wait), 'SCHEDULED', 'SCHEDULED 不在任务终态词表里,但这一轮确实结束了')
// 后端给了个谁都没见过的状态:必须退出。堆一张 terminal 表就会在这里挂死(永不命中)
const mystery = stageHarness(['MYSTAGE'], stageExit)
assert.equal(await waitForTaskTerminal(mystery.wait), 'MYSTAGE')
// 空串仍是「还没轮到结果」,不许当成退出
const blank = stageHarness(['', ''], stageExit)
assert.equal(await waitForTaskTerminal(blank.wait), 'STOPPED', '空状态只能继续等,靠 sleep 兜到 disposed')
assert.ok(blank.sleeps.length > 1, `空状态该按轮 sleep 而不是当场退出:${blank.sleeps.length}`)
})
test('窄词表的后果实测:命不中就只能等 disposed(迁移前正是这一形状)', async () => {
// 同一个 COMPLETED,配上迁移前那份词表 ⇒ 永不命中,只能被 sleep 上限的 disposed 捞出来
const h = stageHarness(['COMPLETED'])
const narrow = { ...h.wait, terminal: ['SUCCESS', 'FAILED'] }
assert.equal(await waitForTaskTerminal(narrow), 'STOPPED', '窄词表下唯一出口是 disposed')
assert.ok(h.sleeps.length > 1, `空转轮次没测出来:${h.sleeps.length}`)
// 对照:共用词表下第一轮就命中,一次都不该 sleep
const wide = stageHarness(['COMPLETED'])
assert.equal(await waitForTaskTerminal(wide.wait), 'COMPLETED')
assert.equal(wide.sleeps.length, 0, '命中终态后不该再 sleep')
})
test('exitOn 只改退出条件,不许把终态词表换掉(任务型等待仍走 terminal)', async () => {
assert.deepEqual([...TERMINAL_TASK_STATUSES].sort(), ['COMPLETED', 'FAILED', 'SUCCESS'])
const noExitOn = stageHarness(['RUNNING', 'COMPLETED'])
assert.equal(await waitForTaskTerminal(noExitOn.wait), 'COMPLETED', '不传 exitOn 时仍按共用词表命中')
})
test('排期那条链的文案与重型取数没被顺手统一掉', () => {
const source = readSource('src/pages/brand/components/BrandShopMatchTab.vue', root).replace(/\r\n/g, '\n')
const start = source.indexOf('async function waitForScheduledTaskStageExit')
assert.notEqual(start, -1, '排期等待函数没了')
const body = source.slice(start, source.indexOf('\nfunction resolvedTaskStatus', start))
for (const phrase of ['继续等待当前轮次结束', '正在等待当前轮次结束', '等待当前轮次结束超时']) {
assert.ok(body.includes(phrase), `文案改了:${phrase}`)
}
assert.ok(body.includes('getShopMatchTaskProgressBatch'), '排期链原本读重型 batch,不该顺手换成 light 端点')
assert.ok(/transientBudget:\s*30/.test(body), '瞬断预算仍是这页原本的 30')
})
@@ -1,14 +1,23 @@
// 终态集合只能有一套:六个品牌 Tab 的"任务到没到终态"判定不许再各写一遍字面量。
// 终态集合只能有一套。这一份判据从"源码正则"升级成 AST(四面9分口径 §2 用户端「判据尺子失明」)。
// 跑法:npm test
import { test } from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import { resolve, dirname } from 'node:path'
import { dirname, resolve, relative, sep } from 'node:path'
import { TERMINAL_TASK_STATUSES } from '../src/shared/utils/task-terminal.ts'
import {
findNarrowTerminalSets,
findWaitFunctions,
listSourceFiles,
readSource,
} from './helpers/task-terminal-ast-ruler.ts'
const here = dirname(fileURLToPath(import.meta.url))
const root = resolve(here, '..')
const rel = (p: string) => relative(root, p).split(sep).join('/')
const SRC_FILES = listSourceFiles(resolve(root, 'src')).map(rel)
const TABS = [
'BrandPatrolDeleteTab.vue',
'BrandPriceTrackTab.vue',
@@ -16,70 +25,180 @@ const TABS = [
'BrandQueryAsinTab.vue',
'BrandShopMatchTab.vue',
'BrandWithdrawTab.vue',
]
].map((f) => `src/pages/brand/components/${f}`)
/**
* 只抓"SUCCESS|FAILED 两个就收尾"的窄集合写法。
* 后面还跟着 COMPLETED / STOPPED 的不算——巡掉/循环跑那类另有自己的终态词表,
* 判据一旦误红,下次就没人信它。
* 迁移后仍留在库里的窄集合(本轮只消掉任务终态那两处:useTaskProgressLoop 的默认词表、
* BrandShopMatchTab 的自写阶段等待)。这一份台账是**只许减**的基线,逐文件钉死:
* 新增一处、或在别处新写一份窄集合,都会红。
*
* 口径:单位=处(一条 `||` 链或一个数组词表算一处),分母=src 下全部 .ts/.vue(.d.ts 除外),
* 命令=`npm test`,尺子=tests/helpers/task-terminal-ast-ruler.ts。
* STOPPED 那几处是巡店/循环跑自己的运行态词表(文档 10-08 口径里旧判据也放过它),不是任务终态;
* fileStatus 那几处是结果文件维度——两处都还没跟后端对过账,所以留在台账里而不是当场改宽。
*/
const NARROW_TERMINAL = /===\s*'SUCCESS'\s*\|\|\s*status\s*===\s*'FAILED'\s*\)/g
function findNarrow(source: string): number[] {
return [...source.matchAll(NARROW_TERMINAL)].map((m) => source.slice(0, m.index).split('\n').length)
const NARROW_LEDGER: Record<string, number> = {
'src/pages/brand/components/BrandAppearancePatentTab.vue': 3,
'src/pages/brand/components/BrandCollectDataTab.vue': 2,
'src/pages/brand/components/BrandDeleteBrandTab.vue': 2,
'src/pages/brand/components/BrandPatrolDeleteTab.vue': 1,
'src/pages/brand/components/BrandPriceTrackTab.vue': 6,
'src/pages/brand/components/BrandProductRiskTab.vue': 2,
'src/pages/brand/components/BrandSimilarAsinTab.vue': 1,
'src/shared/composables/useLiveTaskBoard.ts': 3,
}
const NARROW_BASELINE_TOTAL = Object.values(NARROW_LEDGER).reduce((a, b) => a + b, 0)
test('判据自己先自证:窄写法要被抓到、宽写法不许误报', () => {
assert.deepEqual(findNarrow("if (status === 'SUCCESS' || status === 'FAILED') {"), [1])
assert.deepEqual(findNarrow("if (status === 'SUCCESS' || status === 'FAILED' || status === 'COMPLETED') {"), [],
'含 COMPLETED 的是宽集合,不该报')
assert.deepEqual(findNarrow("return status === 'SUCCESS' || status === 'FAILED' || status === 'STOPPED'"), [],
'循环跑另有词表,不该报')
assert.deepEqual(findNarrow("if (isTerminalTaskStatus(status))"), [], '共用判定不该报')
})
/** 本轮已经迁到共用词表上的文件:这里必须是 0 处,不给"只许减"留讨价还价的余地。 */
const MIGRATED_ZERO_TOLERANCE = [
'src/shared/utils/task-terminal.ts',
'src/shared/composables/useTaskProgressLoop.ts',
'src/pages/brand/components/BrandShopMatchTab.vue',
]
test('六个 Tab 里再无窄终态集合', () => {
const offenders: string[] = []
for (const tab of TABS) {
const source = readFileSync(resolve(here, '../src/pages/brand/components', tab), 'utf-8')
const lines = findNarrow(source)
if (lines.length) offenders.push(`${tab}:${lines.join(',')}`)
/** 上一版尺子的原文(留在测试里当反面对照,不是留着用):变量名不叫 status 就整个看不见。 */
const OLD_NARROW_REGEX = /===\s*'SUCCESS'\s*\|\|\s*status\s*===\s*'FAILED'\s*\)/
/** 任务里点名要能抓到的三个形状。全部走内存字符串,主树一个字节都不动。 */
const COUNTER_EXAMPLES: Array<{ name: string; source: string }> = [
{ name: '同形异名(箭头函数 + 变量叫 s)', source: "const x = (s: string) => s === 'SUCCESS' || s === 'FAILED'" },
{ name: '变量叫 st 的 if 判定', source: "if (st === 'SUCCESS' || st === 'FAILED') return true" },
{ name: '数组 + 枚举 + as any 的 includes', source: '[TaskStatus.SUCCESS, TaskStatus.FAILED].includes(status as any)' },
]
test('尺子先在内存反例上自证:三种同形写法都要变红', () => {
for (const { name, source } of COUNTER_EXAMPLES) {
const hits = findNarrowTerminalSets(source, '<内存反例>')
assert.ok(hits.length > 0, `${name} 没被抓到 ⇒ 尺子对这一形状恒绿:${source}`)
assert.deepEqual([...hits[0].words].sort(), ['FAILED', 'SUCCESS'])
}
assert.deepEqual(offenders, [], `这些位置只认 SUCCESS|FAILED:收到 COMPLETED 会空转到瞬断预算耗尽 —— ${offenders}`)
})
/** 只截 waitForTaskTerminal 的函数体:别处的同名局部变量不该被这条判据算进来。 */
function waitBody(source: string, tab: string): string {
const start = source.indexOf('async function waitForTaskTerminal(taskId: number)')
assert.notEqual(start, -1, `${tab} 里没有 waitForTaskTerminal`)
let depth = 0
let i = source.indexOf('{', start)
for (; i < source.length; i += 1) {
if (source[i] === '{') depth += 1
else if (source[i] === '}') {
depth -= 1
if (depth === 0) break
test('反例同时对照旧正则:证明这次升级真的补上了洞', () => {
for (const { name, source } of COUNTER_EXAMPLES) {
assert.equal(OLD_NARROW_REGEX.test(source), false, `${name} 若被旧正则抓到,那这条对照就失去意义了`)
}
// 非零对照:旧正则能吃的那口(变量名恰好叫 status)新尺子也必须吃得到,不许升级成漏判
assert.ok(findNarrowTerminalSets("if (status === 'SUCCESS' || status === 'FAILED') { return }", '<内存对照>').length > 0)
})
test('宽集合与非终态写法不得误报(判据误红一次就没人再信它)', () => {
const wide = [
"if (status === 'SUCCESS' || status === 'FAILED' || status === 'COMPLETED') return true",
"return ['SUCCESS', 'FAILED', 'COMPLETED', 'CANCELLED'].includes(normalizeStatus(status))",
"st === 'SUCCESS' || st === 'FAILED' || st === 'RUNNING' ? '执行中' : '已完成'",
'isTerminalTaskStatus(status)',
"TERMINAL_TASK_STATUSES.includes(status.trim().toUpperCase())",
]
for (const source of wide) {
assert.deepEqual(findNarrowTerminalSets(source, '<内存宽集合>'), [], `宽/非终态写法被误报了:${source}`)
}
})
test('语法坏掉与 .vue 没有 script 段都必须抛,不许静默返回空清单', () => {
assert.throws(() => findNarrowTerminalSets('const a = (((', '<坏语法>.ts'), /解析失败/)
// 文件名后缀要如实带上:尺子就是靠它决定"要不要先取 <script> 段"
assert.throws(() => findNarrowTerminalSets('<template><div/></template>', '<没script的段>.vue'), /<script> 段数/)
// 两段 script 也要抛:尺子只取一段就是漏判
assert.throws(() => findNarrowTerminalSets('<script>const a = 1</script><script>const b = 2</script>', '<两段script>.vue'), /<script> 段数/)
})
test('终态面这三个文件必须一条窄集合都没有', () => {
const offenders: string[] = []
for (const file of MIGRATED_ZERO_TOLERANCE) {
const hits = findNarrowTerminalSets(readSource(file, root), file)
if (hits.length) offenders.push(`${file}\n ${hits.map((h) => `${h.line}: ${h.snippet}`).join('\n ')}`)
}
assert.deepEqual(offenders, [], `这些地方又在各写一份 SUCCESS|FAILED —— 收到 COMPLETED 就空转:\n${offenders.join('\n')}`)
})
test('useTaskProgressLoop 的默认终态判定确实指向骨架符号', () => {
const source = readSource('src/shared/composables/useTaskProgressLoop.ts', root)
assert.match(source, /import\s*\{\s*isTerminalTaskStatus\s*\}\s*from\s*'\.\.\/utils\/task-terminal\.ts'/,
'没从骨架引判定,DEFAULT_TERMINAL 就是又起了一套词表')
assert.match(source.replace(/\r\n/g, '\n'), /const DEFAULT_TERMINAL = isTerminalTaskStatus\n/,
'DEFAULT_TERMINAL 必须直接指向骨架判定,不许再包一层自写比较')
})
test('把迁移前那两处原样拼回内存里的源码,尺子必须当场变红(不是拼回去改主树)', () => {
// ① useTaskProgressLoop 的第二套词表本体
const loopFile = 'src/shared/composables/useTaskProgressLoop.ts'
const loopSource = readSource(loopFile, root).replace(/\r\n/g, '\n')
const anchor = 'const DEFAULT_TERMINAL = isTerminalTaskStatus'
assert.equal(loopSource.split(anchor).length - 1, 1, '锚点不唯一,这条自证不作数')
const splicedLoop = loopSource.replace(anchor, "const DEFAULT_TERMINAL = (status: string) => status === 'SUCCESS' || status === 'FAILED'")
assert.notEqual(splicedLoop, loopSource, '注入没生效')
assert.ok(findNarrowTerminalSets(splicedLoop, loopFile).length > 0,
'把迁移前那行拼回去,零容忍清单却没变红 ⇒ 这条判据是恒绿的')
// ② BrandShopMatchTab 的自写阶段等待循环
const tabFile = 'src/pages/brand/components/BrandShopMatchTab.vue'
const tabSource = readSource(tabFile, root).replace(/\r\n/g, '\n')
const tabAnchor = 'async function waitForScheduledTaskStageExit(taskId: number) {'
assert.equal(tabSource.split(tabAnchor).length - 1, 1, '锚点不唯一,这条自证不作数')
const splicedTab = tabSource.replace(tabAnchor, `${tabAnchor}
let transientErrorCount = 0
while (true) {
if (disposed) return 'STOPPED'
transientErrorCount += 1
if (transientErrorCount > 30) return 'FAILED'
await sleep(getPollIntervalMs())
}`)
const shapes = findWaitFunctions(splicedTab, tabFile)
const stage = shapes.find((f) => f.name === 'waitForScheduledTaskStageExit')
assert.ok(stage, '拼了自写循环却没扫到这个函数')
assert.ok(stage!.hasWhileTrue || stage!.declaresTransientCounter,
'自写 while(true) + 瞬断计数没被抓到 ⇒ "都上骨架"那条判据是恒绿的')
})
test('全 src 窄集合只许减:逐文件台账 + 分母自证', () => {
// 分母自证:文件遍历坏掉会让所有尺子恒绿
assert.ok(SRC_FILES.length > 100, `src 只扫到 ${SRC_FILES.length} 个文件,分母不对,判据不可信`)
assert.ok(SRC_FILES.some((f) => f.endsWith('.vue')) && SRC_FILES.some((f) => f.endsWith('.ts')))
const perFile: Record<string, number> = {}
const unexpected: string[] = []
for (const file of SRC_FILES) {
const hits = findNarrowTerminalSets(readSource(file, root), file)
if (!hits.length) continue
perFile[file] = hits.length
const allowed = NARROW_LEDGER[file]
if (allowed === undefined) unexpected.push(`${file} 是新增窄集合的文件:\n ${hits.map((h) => `${h.line}: ${h.snippet}`).join('\n ')}`)
else if (hits.length > allowed) unexpected.push(`${file} 从 ${allowed} 处涨到 ${hits.length} 处:\n ${hits.map((h) => `${h.line}: ${h.snippet}`).join('\n ')}`)
}
assert.deepEqual(unexpected, [], unexpected.join('\n\n'))
const total = Object.values(perFile).reduce((a, b) => a + b, 0)
assert.ok(total <= NARROW_BASELINE_TOTAL, `全 src 窄集合 ${total} 处,超基线 ${NARROW_BASELINE_TOTAL} 处;台账只许减:\n${JSON.stringify(perFile, null, 1)}`)
// 台账里的文件必须真的还在命中:悄悄改了别处、把账目改成"0"也是绕过
for (const [file, count] of Object.entries(NARROW_LEDGER)) {
assert.equal(perFile[file], count, `${file} 的窄集合处数与台账不符(实测 ${perFile[file]},台账 ${count})——要么改了代码要么改了台账,两者要一起`)
}
})
test('六个 Tab 的每条等待函数都真的走骨架(按 AST 认函数,不靠签名切字符串)', () => {
const offenders: string[] = []
const seen: string[] = []
for (const tab of TABS) {
const source = readSource(tab, root)
const fns = findWaitFunctions(source, tab)
assert.ok(fns.length >= 1, `${tab} 里一个 waitFor* 函数都没有,判据无从下手`)
for (const fn of fns) {
seen.push(`${relative(root, tab) || tab}#${fn.name}`)
if (!fn.calls.includes('waitForTaskTerminalShared')) offenders.push(`${tab}#${fn.name} 没调共用骨架`)
if (fn.hasWhileTrue) offenders.push(`${tab}#${fn.name} 仍自己写 while (true)`)
if (fn.declaresTransientCounter) offenders.push(`${tab}#${fn.name} 仍自己数瞬断`)
}
}
return source.slice(start, i + 1)
}
test('六个 Tab 的等待循环都真的走了共用骨架', () => {
const offenders: string[] = []
for (const tab of TABS) {
const source = readFileSync(resolve(here, '../src/pages/brand/components', tab), 'utf-8')
const body = waitBody(source, tab)
if (!body.includes('waitForTaskTerminalShared(')) offenders.push(`${tab} 没调骨架`)
// 骨架之外不该再有第二份 while (true) 的等待循环:`let transientErrorCount` 是它的签名
if (/let transientErrorCount/.test(body)) offenders.push(`${tab} 仍自己数瞬断`)
if (/while\s*\(\s*true\s*\)/.test(body)) offenders.push(`${tab} 仍自己写循环`)
}
assert.deepEqual(offenders, [], `这些页还在各写一份循环:${offenders}`)
assert.deepEqual(offenders, [], `这些等待循环还在各写一份:${offenders}`)
// 排期那条链(waitForScheduledTaskStageExit)也必须在名单里——上一期就是漏了它才有第二份循环
assert.ok(seen.some((s) => s.includes('waitForScheduledTaskStageExit')), `没扫到 waitForScheduledTaskStageExit:${seen.join(', ')}`)
})
test('被改宽的两页确实改用共用判定了', () => {
for (const tab of ['BrandPriceTrackTab.vue', 'BrandProductRiskTab.vue']) {
const source = readFileSync(resolve(here, '../src/pages/brand/components', tab), 'utf-8')
const source = readSource(`src/pages/brand/components/${tab}`, root)
assert.match(source, /from '@\/shared\/utils\/task-terminal'/, `${tab} 没引共用终态判定`)
assert.ok(source.includes('isTerminalTaskStatus('), `${tab} 引了但没用`)
}
@@ -87,7 +206,7 @@ test('被改宽的两页确实改用共用判定了', () => {
test('COMPLETED 与 SUCCESS 同类的口径两头都有出处', () => {
// 前端显示表:两个状态都是「已完成」/success 样式
const display = readFileSync(resolve(here, '../src/shared/utils/task-status-text.ts'), 'utf-8')
const display = readSource('src/shared/utils/task-status-text.ts', root)
for (const key of TERMINAL_TASK_STATUSES) {
assert.ok(display.includes(`${key}:`), `显示表里没有 ${key},统一集合就成了无源之水`)
}