369 lines
17 KiB
JavaScript
369 lines
17 KiB
JavaScript
// 任务生命周期测试:重点验证「完成判定三分支」与乱序/重复事件不回退状态。
|
||
// 这些是 v0.1 最容易出错的地方,全部用纯函数直接断言,不依赖 store 或宿主。
|
||
|
||
import test from 'node:test'
|
||
import assert from 'node:assert/strict'
|
||
|
||
import {
|
||
TaskError,
|
||
TASK_TRANSITIONS,
|
||
isStaleSeq,
|
||
isRegressingEvent,
|
||
createTask,
|
||
startTask,
|
||
beginAttempt,
|
||
validateReport,
|
||
checkCompletion,
|
||
evaluateCompletion,
|
||
decide,
|
||
requestInput,
|
||
supplyInput,
|
||
completeTask,
|
||
failTask,
|
||
cancelTask,
|
||
applyDecision,
|
||
isOpenTask,
|
||
} from '../core/tasks.mjs'
|
||
import { WorkbenchStore } from '../core/store.mjs'
|
||
|
||
const clock = () => 1700000000000
|
||
|
||
function draftTask(overrides = {}) {
|
||
return createTask(
|
||
{
|
||
projectId: 'proj_a',
|
||
title: '整理季度报表',
|
||
objective: '把三份表合并成一份差异表',
|
||
ownerRoleId: 'hubu',
|
||
sourceRoleId: 'zhongshu',
|
||
...overrides,
|
||
},
|
||
{ newTaskId: () => 'task_1', now: clock },
|
||
)
|
||
}
|
||
|
||
function runningTask() {
|
||
const task = startTask(draftTask(), { now: clock })
|
||
return beginAttempt(task, { id: 'att_1', projectId: 'proj_a', taskId: 'task_1' }, { now: clock })
|
||
}
|
||
|
||
const goodReport = {
|
||
attemptId: 'att_1',
|
||
taskId: 'task_1',
|
||
summary: '差异 12 处,已附差异表',
|
||
checks: [{ name: '数量核对', ok: true }],
|
||
artifactRefs: ['art_1'],
|
||
}
|
||
|
||
test('createTask 只建草稿,缺字段或未知席直接拒绝', () => {
|
||
const task = draftTask()
|
||
assert.equal(task.status, 'draft')
|
||
assert.equal(task.ownerRoleId, 'hubu')
|
||
assert.equal(task.sourceRoleId, 'zhongshu')
|
||
assert.equal(task.activeAttemptId, null)
|
||
assert.equal(task.revision, 1)
|
||
assert.deepEqual(task.attempts, [])
|
||
assert.throws(() => createTask({ title: 'x', objective: 'y', ownerRoleId: 'hubu' }), TaskError)
|
||
assert.throws(() => draftTask({ ownerRoleId: 'hufu' }), /未知主责部门/)
|
||
assert.throws(() => draftTask({ sourceRoleId: 'nobody' }), /未知来源部门/)
|
||
assert.throws(() => draftTask({ objective: ' ' }), /objective/)
|
||
})
|
||
|
||
test('TASK_TRANSITIONS 与方案一致且不可变', () => {
|
||
assert.ok(Object.isFrozen(TASK_TRANSITIONS))
|
||
const pairs = TASK_TRANSITIONS.map(([from, to]) => `${from}->${to}`)
|
||
for (const expected of ['draft->queued', 'running->completed', 'running->needs_attention', 'needs_attention->completed', 'waiting_input->running']) {
|
||
assert.ok(pairs.includes(expected), `缺少迁移 ${expected}`)
|
||
}
|
||
assert.ok(!pairs.includes('completed->running'), '终态不能被复活')
|
||
assert.ok(Object.isFrozen(TASK_TRANSITIONS[0]))
|
||
})
|
||
|
||
test('startTask 只从草稿或待补充入队', () => {
|
||
const queued = startTask(draftTask(), { now: clock })
|
||
assert.equal(queued.status, 'queued')
|
||
assert.equal(queued.revision, 2)
|
||
assert.throws(() => startTask(queued), /只有草稿或待补充/)
|
||
const waiting = requestInput(runningTask(), '缺少上月口径', { now: clock }).task
|
||
assert.equal(waiting.status, 'waiting_input')
|
||
assert.equal(startTask(waiting, { now: clock }).status, 'queued')
|
||
})
|
||
|
||
test('beginAttempt 绑定新尝试并保留历史', () => {
|
||
const task = runningTask()
|
||
assert.equal(task.status, 'running')
|
||
assert.equal(task.activeAttemptId, 'att_1')
|
||
assert.deepEqual(task.attempts, ['att_1'])
|
||
// 旧尝试仍活跃时不允许并发换绑:先对账再重试
|
||
assert.throws(
|
||
() => beginAttempt(task, { id: 'att_2', projectId: 'proj_a', taskId: 'task_1' }),
|
||
(error) => error.code === 'ACTIVE_ATTEMPT',
|
||
)
|
||
const settled = { ...task, activeAttemptId: null, status: 'needs_attention' }
|
||
const retried = beginAttempt(settled, { id: 'att_2', projectId: 'proj_a', taskId: 'task_1' }, { now: clock })
|
||
assert.equal(retried.activeAttemptId, 'att_2')
|
||
assert.deepEqual(retried.attempts, ['att_1', 'att_2'], '旧尝试不能被覆盖')
|
||
assert.throws(() => beginAttempt({ ...task, status: 'completed' }, { id: 'att_3', projectId: 'proj_a', taskId: 'task_1' }), /不能开始新的尝试/)
|
||
assert.throws(
|
||
() => beginAttempt({ ...task, status: 'queued' }, { id: 'att_2', projectId: 'proj_b', taskId: 'task_1' }),
|
||
/不属于同一项目/,
|
||
)
|
||
assert.throws(
|
||
() => beginAttempt({ ...task, status: 'queued' }, { id: 'att_2', projectId: 'proj_a', taskId: 'task_9' }),
|
||
/别的任务/,
|
||
)
|
||
assert.throws(() => beginAttempt({ ...task, status: 'queued' }, null), /尝试记录不合法/)
|
||
})
|
||
|
||
test('beginAttempt 不再被已取消的旧尝试挡住重试', () => {
|
||
const running = runningTask()
|
||
// 取消后 activeAttemptId 仍指向旧尝试(保留审计),旧 Attempt 已转 cancelled 终态 → 允许重试
|
||
const cancelledLookup = (id) => ({ id, state: 'cancelled' })
|
||
const next = { id: 'att_2', projectId: 'proj_a', taskId: 'task_1' }
|
||
const retried = beginAttempt(running, next, { now: clock, attemptLookup: cancelledLookup })
|
||
assert.equal(retried.status, 'running')
|
||
assert.equal(retried.activeAttemptId, 'att_2')
|
||
assert.deepEqual(retried.attempts, ['att_1', 'att_2'], '旧尝试保留在历史里')
|
||
// running 但当前尝试已 unknown/failed/succeeded 终态时同样放行
|
||
for (const state of ['failed', 'succeeded']) {
|
||
assert.equal(beginAttempt(running, next, { now: clock, attemptLookup: (id) => ({ id, state }) }).activeAttemptId, 'att_2')
|
||
}
|
||
// needs_attention 下旧尝试已取消:不被 ACTIVE_ATTEMPT 挡住
|
||
const needsAttention = { ...running, status: 'needs_attention' }
|
||
const retriedAfterCancel = beginAttempt(needsAttention, next, { now: clock, attemptLookup: cancelledLookup })
|
||
assert.equal(retriedAfterCancel.status, 'running')
|
||
assert.equal(retriedAfterCancel.needsAttentionReason, null)
|
||
// 旧尝试 still running / unknown / cancel_requested:仍在活动,必须挡住
|
||
const queuedAttempt = (id) => ({ id, state: 'queued' })
|
||
const unknownAttempt = (id) => ({ id, state: 'unknown' })
|
||
for (const lookup of [queuedAttempt, unknownAttempt]) {
|
||
assert.throws(
|
||
() => beginAttempt(running, next, { now: clock, attemptLookup: lookup }),
|
||
(error) => error.code === 'ACTIVE_ATTEMPT',
|
||
)
|
||
assert.throws(
|
||
() => beginAttempt(needsAttention, next, { now: clock, attemptLookup: lookup }),
|
||
(error) => error.code === 'ACTIVE_ATTEMPT',
|
||
)
|
||
}
|
||
// 不注入 attemptLookup 时无法证明旧尝试已对账 → 保持旧行为(非空即挡)
|
||
assert.throws(
|
||
() => beginAttempt(running, next, { now: clock }),
|
||
(error) => error.code === 'ACTIVE_ATTEMPT',
|
||
)
|
||
// needs_attention 且 activeAttemptId 为空 → 本来就不受影响
|
||
assert.equal(beginAttempt({ ...running, activeAttemptId: null, status: 'needs_attention' }, next, { now: clock }).activeAttemptId, 'att_2')
|
||
})
|
||
|
||
test('validateReport 只认结构化字段', () => {
|
||
assert.deepEqual(validateReport(goodReport), [])
|
||
assert.deepEqual(validateReport({ attemptId: 'a', taskId: 't', summary: 's' }), [])
|
||
assert.deepEqual(validateReport(null), ['报告必须是对象'])
|
||
const errors = validateReport({ summary: ' ', artifactRefs: ['res_1'], checks: 'ok' })
|
||
assert.ok(errors.some((row) => row.includes('attemptId')))
|
||
assert.ok(errors.some((row) => row.includes('taskId')))
|
||
assert.ok(errors.some((row) => row.includes('摘要为空')))
|
||
assert.ok(errors.some((row) => row.includes('成果引用形状非法')))
|
||
assert.ok(errors.some((row) => row.includes('checks 必须是数组')))
|
||
assert.ok(validateReport({ attemptId: 'a', taskId: 't', summary: 's', artifactRefs: 'art_1' }).some((row) => row.includes('artifactRefs')))
|
||
})
|
||
|
||
test('checkCompletion 三条条件各占一票', () => {
|
||
const all = checkCompletion({ report: goodReport, runTerminal: 'succeeded', artifactRefs: ['art_1'], artifactLookup: () => ({ id: 'art_1' }) })
|
||
assert.deepEqual(all, { reportOk: true, runOk: true, refsValid: true, blockers: [], ok: true })
|
||
|
||
const noReport = checkCompletion({ report: null, runTerminal: 'succeeded' })
|
||
assert.equal(noReport.reportOk, false)
|
||
assert.equal(noReport.ok, false)
|
||
assert.ok(noReport.blockers.includes('未收到结构化报告'))
|
||
|
||
const noTerminal = checkCompletion({ report: goodReport, runTerminal: null })
|
||
assert.equal(noTerminal.runOk, false)
|
||
assert.ok(noTerminal.blockers.includes('宿主运行尚未结束'))
|
||
|
||
const failedRun = checkCompletion({ report: goodReport, runTerminal: 'failed' })
|
||
assert.equal(failedRun.runOk, false)
|
||
assert.ok(failedRun.blockers.some((row) => row.includes('failed')))
|
||
|
||
const blocked = checkCompletion({ report: { ...goodReport, blockedReason: '缺权限' }, runTerminal: 'succeeded' })
|
||
assert.equal(blocked.reportOk, false)
|
||
|
||
const danglingRef = checkCompletion({ report: goodReport, runTerminal: 'succeeded', artifactRefs: ['art_1'], artifactLookup: () => undefined })
|
||
assert.equal(danglingRef.refsValid, false)
|
||
assert.ok(danglingRef.blockers.some((row) => row.includes('成果引用无效')))
|
||
|
||
const missingArtifact = checkCompletion({ report: goodReport, runTerminal: 'succeeded', artifactRefs: ['art_1'], artifactLookup: () => ({ id: 'art_1', verification: { status: 'missing' } }) })
|
||
assert.equal(missingArtifact.refsValid, false)
|
||
|
||
// 纯分析任务允许无附件:空引用不算失败
|
||
assert.equal(checkCompletion({ report: goodReport, runTerminal: 'succeeded', artifactRefs: [] }).ok, true)
|
||
})
|
||
|
||
test('完成判定三分支:三者齐全 → completed', () => {
|
||
const decision = evaluateCompletion(
|
||
runningTask(),
|
||
{ report: goodReport, runTerminal: 'succeeded', artifactRefs: ['art_1'], artifactLookup: () => ({ id: 'art_1' }) },
|
||
{ now: clock },
|
||
)
|
||
assert.equal(decision.applied, true)
|
||
assert.equal(decision.task.status, 'completed')
|
||
assert.ok(decision.task.reportReceivedAt)
|
||
assert.equal(decision.task.needsAttentionReason, null)
|
||
})
|
||
|
||
test('完成判定三分支:只有报告 → 等待,不置 completed', () => {
|
||
// 报告先到:保存候选结果,等宿主终态
|
||
const reported = decide(runningTask(), { kind: 'report', report: goodReport }, { now: clock })
|
||
assert.equal(reported.applied, true)
|
||
assert.equal(reported.task.status, 'running', '报告先到不得直接置完成')
|
||
assert.ok(reported.task.reportReceivedAt !== null)
|
||
|
||
// 只有报告、终态尚未到达 —— 保持 running
|
||
const pending = evaluateCompletion(runningTask(), { report: goodReport, runTerminal: null })
|
||
assert.equal(pending.applied, false)
|
||
assert.equal(pending.task.status, 'running')
|
||
assert.ok(pending.reason.includes('宿主运行尚未结束'))
|
||
|
||
// 报告到达后终态成功 → 顺理成章完成
|
||
const finished = decide(reported.task, { kind: 'run_terminal', runTerminal: 'succeeded' }, { now: clock })
|
||
assert.equal(finished.applied, true)
|
||
assert.equal(finished.task.status, 'completed')
|
||
})
|
||
|
||
test('完成判定三分支:只有终态 → needs_attention', () => {
|
||
// 宿主运行先结束但无报告
|
||
const onlyTerminal = evaluateCompletion(runningTask(), { report: null, runTerminal: 'succeeded' }, { now: clock })
|
||
assert.equal(onlyTerminal.applied, true)
|
||
assert.equal(onlyTerminal.task.status, 'needs_attention')
|
||
assert.match(onlyTerminal.task.needsAttentionReason, /没有有效的结构化报告/)
|
||
|
||
// 运行失败同样进入 needs_attention,而不是 completed
|
||
const failed = decide(runningTask(), { kind: 'run_terminal', runTerminal: 'failed' }, { now: clock })
|
||
assert.equal(failed.task.status, 'needs_attention')
|
||
assert.match(failed.task.needsAttentionReason, /failed/)
|
||
|
||
// 终态成功但报告不完整:也不能置完成,最多进入 needs_attention 等补报
|
||
const partial = evaluateCompletion(runningTask(), { report: { attemptId: 'att_1' }, runTerminal: 'succeeded' })
|
||
assert.notEqual(partial.task.status, 'completed')
|
||
assert.equal(partial.task.status, 'needs_attention')
|
||
})
|
||
|
||
test('运行终态为 cancelled 时任务直接取消', () => {
|
||
const decision = decide(runningTask(), { kind: 'run_terminal', runTerminal: 'cancelled' }, { now: clock })
|
||
assert.equal(decision.task.status, 'cancelled')
|
||
assert.ok(decision.task.endedAt)
|
||
})
|
||
|
||
test('乱序事件:旧 seq 不回退,迟到 running 不覆盖终态', () => {
|
||
assert.equal(isStaleSeq(null, 5), false)
|
||
assert.equal(isStaleSeq(5, 5), true, '同 seq 视为重复')
|
||
assert.equal(isStaleSeq(5, 4), true)
|
||
assert.equal(isStaleSeq(5, 6), false)
|
||
assert.equal(isStaleSeq(5, Number.NaN), true)
|
||
|
||
const withSeq = { ...runningTask(), lastSeq: 10 }
|
||
const stale = decide(withSeq, { kind: 'input_required', reason: '旧事件', seq: 9 }, { now: clock })
|
||
assert.equal(stale.applied, false)
|
||
assert.equal(stale.stale, true)
|
||
assert.equal(stale.task.status, 'running')
|
||
|
||
const done = evaluateCompletion(
|
||
{ ...withSeq, lastSeq: 11 },
|
||
{ report: goodReport, runTerminal: 'succeeded', seq: 12 },
|
||
{ now: clock },
|
||
)
|
||
assert.equal(done.task.status, 'completed')
|
||
assert.equal(done.task.lastSeq, 12)
|
||
|
||
const late = decide(done.task, { kind: 'input_required', reason: '迟到的求助', seq: 13 }, { now: clock })
|
||
assert.equal(late.applied, false)
|
||
assert.equal(late.task.status, 'completed', '终态不能被迟到事件覆盖')
|
||
// 终态之后即使 seq 更大也只记 no-op:调用方据此知道「没有状态变化」
|
||
assert.match(late.reason, /不接受|已终态/)
|
||
|
||
assert.equal(isRegressingEvent('completed', 'running'), true)
|
||
assert.equal(isRegressingEvent('completed', 'completed'), false)
|
||
assert.equal(isRegressingEvent('running', 'running'), false)
|
||
})
|
||
|
||
test('waiting_input 往返与非法事件', () => {
|
||
const asked = requestInput(runningTask(), '缺口径', { now: clock })
|
||
assert.equal(asked.task.status, 'waiting_input')
|
||
assert.equal(asked.task.waitingReason, '缺口径')
|
||
const back = supplyInput(asked.task, { now: clock })
|
||
assert.equal(back.task.status, 'running')
|
||
assert.equal(back.task.waitingReason, null)
|
||
assert.equal(supplyInput(back.task).applied, false, '不在待补充时忽略')
|
||
assert.equal(requestInput(draftTask(), 'x').applied, false)
|
||
assert.throws(() => decide(runningTask(), { kind: 'nope' }), /未知事件类型/)
|
||
assert.throws(() => decide(runningTask(), null), /事件必须是对象/)
|
||
assert.throws(() => decide({}, { kind: 'report' }), /任务记录不合法/)
|
||
assert.throws(
|
||
() => decide(runningTask(), { kind: 'report', report: { summary: '' } }),
|
||
(error) => error.code === 'INVALID_REPORT',
|
||
)
|
||
assert.throws(
|
||
() => decide({ ...runningTask(), status: 'failed' }, { kind: 'retry' }),
|
||
(error) => error.code === 'RETRY_REQUIRES_NEW_TASK',
|
||
)
|
||
assert.equal(decide(runningTask(), { kind: 'retry' }).applied, false)
|
||
})
|
||
|
||
test('failTask 必须带原因,终态后忽略', () => {
|
||
const failed = failTask(runningTask(), '模型超时', { now: clock })
|
||
assert.equal(failed.task.status, 'failed')
|
||
assert.equal(failed.task.failureReason, '模型超时')
|
||
assert.ok(failed.task.endedAt)
|
||
assert.throws(() => failTask(runningTask(), ' '), /reason/)
|
||
assert.equal(failTask(failed.task, 'again').applied, false)
|
||
})
|
||
|
||
test('cancelTask 记录取消原因且只写一次结束时间', () => {
|
||
const cancelled = cancelTask(runningTask(), '用户点了取消', { now: clock })
|
||
assert.equal(cancelled.task.status, 'cancelled')
|
||
assert.equal(cancelled.task.cancelReason, '用户点了取消')
|
||
const again = cancelTask(cancelled.task, '重复取消')
|
||
assert.equal(again.applied, false)
|
||
assert.equal(again.task.endedAt, cancelled.task.endedAt)
|
||
assert.equal(cancelTask(draftTask()).task.cancelReason, '用户取消')
|
||
})
|
||
|
||
test('completeTask 是 completion 事件的便捷包装', () => {
|
||
const decision = completeTask(
|
||
runningTask(),
|
||
{ report: goodReport, runTerminal: 'succeeded', artifactRefs: ['art_1'], artifactLookup: () => ({ id: 'art_1' }), seq: 3 },
|
||
)
|
||
assert.equal(decision.task.status, 'completed')
|
||
assert.equal(decision.task.lastSeq, 3)
|
||
})
|
||
|
||
test('applyDecision 只在 applied 时落库', () => {
|
||
const store = new WorkbenchStore({ file: null, clock, random: () => 3 })
|
||
const projectId = store.createProject({ hostWorkspaceId: 'ws-a' })
|
||
const created = createTask(
|
||
{ projectId, title: 't', objective: 'o', ownerRoleId: 'hubu' },
|
||
{ newTaskId: () => 'task_1', now: clock },
|
||
)
|
||
store.insertTask(created)
|
||
const queued = startTask(store.getTask('task_1'), { now: clock })
|
||
const stale = applyDecision(store, 'task_1', { applied: false, stale: true, task: created })
|
||
assert.equal(stale.applied, false)
|
||
assert.equal(store.getTask('task_1').revision, 1, '陈旧事件不得产生版本抖动')
|
||
|
||
const started = applyDecision(store, 'task_1', { applied: true, stale: false, task: queued })
|
||
assert.equal(started.task.status, 'queued')
|
||
assert.equal(store.getTask('task_1').status, 'queued')
|
||
// null 会被默认参数换成 undefined,所以显式传 undefined 才能走到 store 校验
|
||
assert.throws(() => applyDecision(undefined, 'task_1', {}), /需要 store/)
|
||
// 未启用的事件不得落库:返回原判定,store 保持 revision 不变
|
||
assert.equal(applyDecision(store, 'task_1', { applied: false, task: queued }).task.status, 'queued')
|
||
assert.throws(() => applyDecision(store, 'task_1', null), /判定结果不合法/)
|
||
})
|
||
|
||
test('isOpenTask 区分终态与活动态', () => {
|
||
assert.equal(isOpenTask(draftTask()), true)
|
||
assert.equal(isOpenTask(cancelTask(draftTask()).task), false)
|
||
assert.equal(isOpenTask(null), false)
|
||
assert.equal(isOpenTask({ status: 'bogus' }), false)
|
||
})
|