feat(short-drama-agent-front): 完善分镜审核与制作准备流程

This commit is contained in:
GJ committed 2026-10-19 21:59:22 +08:00
1 parent c4b43b9725
commit 1da56e0d46
72 files changed
+2801 -528

No files matched your search

+19 -19
View File
@@ -1,3 +1,4 @@
import { policyReceipt } from '../../fixtures/quality-policy'
import { computed, ref } from 'vue'
import { DOMWrapper, flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { afterEach, describe, expect, it, vi } from 'vitest'
@@ -22,10 +23,7 @@ import { getOperation } from '@/features/workflows/operations'
let wrapper: VueWrapper | undefined
it('首次点击生成先读取并确认质量规则,不直接打开模型启动确认', async () => {
const readPolicy = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({
projectId: 'breakdown-scroll-test',
policy: { version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] }
})
const readPolicy = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('breakdown-scroll-test', { version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] }))
vi.spyOn(breakdownApi, 'preview').mockResolvedValue({
episodeCount: 1, groupCount: 1, estimatedTaskCount: 3, tasks: [], modules: ['character', 'scene', 'prop'], groupSize: 3,
groups: [{ groupId: 'preview-group', groupNo: 1, startEpisodeNo: 1, endEpisodeNo: 1, episodes: [] }]
@@ -45,9 +43,11 @@ it('首次点击生成先读取并确认质量规则,不直接打开模型启
})
it('规则确认保留分组预览,隐藏空白例外,确认不调用模型,未变规则不重复打开表单', async () => {
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({
projectId: 'breakdown-scroll-test',
policy: { version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] }
const result = policyReceipt('breakdown-scroll-test', { version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] })
vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => structuredClone(result))
vi.spyOn(projectsApi, 'confirmQualityPolicy').mockImplementation(async () => {
Object.assign(result, { confirmed: true, confirmedRevision: 2, confirmedAt: '2026-10-17T15:00:00Z' })
return structuredClone(result)
})
vi.spyOn(breakdownApi, 'preview').mockResolvedValue({
episodeCount: 1, groupCount: 1, estimatedTaskCount: 3, tasks: [], modules: ['character', 'scene', 'prop'], groupSize: 3,
@@ -84,12 +84,12 @@ it('规则确认保留分组预览,隐藏空白例外,确认不调用模型
it('当前动作问题在问题抽屉中提供例外修订,保存期间锁定关闭且保存后仍需审核', async () => {
let policy: ProjectQualityPolicy = { version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] }
vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => ({ projectId: 'breakdown-scroll-test', policy }))
vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => policyReceipt('breakdown-scroll-test', policy))
let finish!: () => void
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(async (id, input) => {
await new Promise<void>(resolve => { finish = resolve })
policy = input
return { projectId: id, policy: input }
return policyReceipt(id, input)
})
vi.spyOn(breakdownApi, 'revalidateCandidate').mockResolvedValue(candidateReview({
projectId: 'breakdown-scroll-test', actionQualityBlocks: [{ episodeNo: 1, beatNo: 1, shotNo: 1, status: 'blocked', blockingCodes: ['action_resource_conflict'], warningCodes: [], isPendingEpisode: true }], pendingQualityEpisodeNos: [1]
@@ -400,7 +400,7 @@ function handDiagnosticsResponse(evidenceShotCount: number) {
* @returns 当前动作诊断弹窗
*/
function qualityDialog() {
const panel = document.querySelector<HTMLElement>('.app-dialog[aria-label="动作诊断"]')
const panel = document.querySelector<HTMLElement>('.app-drawer[aria-label="动作诊断"]')
if (!panel) throw new Error('动作诊断弹窗未打开')
return new DOMWrapper(panel)
}
@@ -751,7 +751,7 @@ describe('拆解页内容滚动', () => {
const fetcher = vi.fn<typeof fetch>().mockImplementation(async input => {
const url = String(input)
if (url.includes('storyboard-legacy-action-diagnosis-results')) return diagnosisResultsResponse()
if (url.endsWith('storyboard-hand-occupancy-diagnostics')) return handDiagnosticsResponse(0)
if (url.endsWith('storyboard-action-resource-diagnostics')) return handDiagnosticsResponse(0)
throw new Error(`未预期的诊断请求:${url}`)
})
vi.stubGlobal('fetch', fetcher)
@@ -765,7 +765,7 @@ describe('拆解页内容滚动', () => {
const panel = qualityDialog()
expect(panel.findAll('button').some(button => button.text() === '刷新校验')).toBe(false)
expect(panel.get('.storyboard-diagnosis-dialog').attributes('aria-busy')).toBe('false')
const footer = panel.get('.n-card__footer')
const footer = panel.get('.n-drawer-footer')
expect(footer.text()).toContain('预览诊断范围')
expect(footer.text()).toContain('启动 AI 诊断')
expect(footer.text()).toContain('关闭')
@@ -778,7 +778,7 @@ describe('拆解页内容滚动', () => {
await flushPromises()
expect(panel.findAll('button').some(button => button.text() === '刷新校验')).toBe(false)
expect(
fetcher.mock.calls.filter(([input]) => String(input).endsWith('storyboard-hand-occupancy-diagnostics'))
fetcher.mock.calls.filter(([input]) => String(input).endsWith('storyboard-action-resource-diagnostics'))
).toHaveLength(1)
})
@@ -795,7 +795,7 @@ describe('拆解页内容滚动', () => {
})
return diagnosisResultsResponse()
}
if (url.endsWith('storyboard-hand-occupancy-diagnostics')) return handDiagnosticsResponse(0)
if (url.endsWith('storyboard-action-resource-diagnostics')) return handDiagnosticsResponse(0)
throw new Error(`未预期的诊断请求:${url}`)
})
vi.stubGlobal('fetch', fetcher)
@@ -807,7 +807,7 @@ describe('拆解页内容滚动', () => {
await panel.findAll('.n-collapse-item__header-main')[1]!.trigger('click')
await flushPromises()
const content = panel.get('.diagnosis-dialog-content').element
const scroll = panel.get<HTMLElement>('.dialog-body-scroll .n-scrollbar-container').element
const scroll = panel.get<HTMLElement>('.n-drawer-body .n-scrollbar-container').element
scroll.scrollTop = 80
const refreshButton = panel.findAll('button').find(button => button.text() === '刷新结果')!
const refreshIcon = refreshButton.get('.n-button__icon').element
@@ -838,7 +838,7 @@ describe('拆解页内容滚动', () => {
const fetcher = vi.fn<typeof fetch>().mockImplementation(async input => {
const url = String(input)
if (url.includes('storyboard-legacy-action-diagnosis-results')) return diagnosisResultsResponse()
if (url.endsWith('storyboard-hand-occupancy-diagnostics')) {
if (url.endsWith('storyboard-action-resource-diagnostics')) {
handRequests++
if (handRequests > 1)
return new Promise<Response>(resolve => {
@@ -886,7 +886,7 @@ describe('拆解页内容滚动', () => {
const fetcher = vi.fn<typeof fetch>().mockImplementation(async input => {
const url = String(input)
if (url.includes('storyboard-legacy-action-diagnosis-results')) return diagnosisResultsResponse()
if (url.endsWith('storyboard-hand-occupancy-diagnostics')) {
if (url.endsWith('storyboard-action-resource-diagnostics')) {
handRequests++
if (handRequests === 1)
return new Promise<Response>(resolve => {
@@ -906,13 +906,13 @@ describe('拆解页内容滚动', () => {
expect(qualityDialog().text()).not.toContain('诊断结果')
expect(
qualityDialog()
.get('.n-card__footer')
.get('.n-drawer-footer')
.findAll('button')
.filter(button => button.text() !== '关闭')
.every(button => (button.element as HTMLButtonElement).disabled)
).toBe(true)
const close = qualityDialog()
.get('.n-card__footer')
.get('.n-drawer-footer')
.findAll('button')
.find(button => button.text() === '关闭')!
expect((close.element as HTMLButtonElement).disabled).toBe(false)
@@ -1,3 +1,4 @@
import { policyReceipt } from '../../fixtures/quality-policy'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import { actionExceptionTargets } from '@/features/breakdown/action-exceptions'
@@ -68,8 +69,8 @@ describe('从实际问题建立动作例外', () => {
it('用户仅填写原因,保存前重读并合并已有例外,不改全局规则或自动放行质量', async () => {
const { state, quality } = conflict()
const latest = { ...policy, customRules: ['其他入口刚保存的新规则'] }
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValueOnce({ projectId: 'candidate-project', policy }).mockResolvedValue({ projectId: 'candidate-project', policy: latest })
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(async (id, input) => ({ projectId: id, policy: input }))
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValueOnce(policyReceipt('candidate-project', policy)).mockResolvedValue(policyReceipt('candidate-project', latest))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(async (id, input) => (policyReceipt(id, input)))
wrapper = mount(ActionExceptionRepair, { props: { projectId: 'candidate-project', checkpointId: 'candidate-current', state, quality, disabled: false } })
await flushPromises()
expect(wrapper.text()).toContain('左手握住铜铃')
@@ -87,7 +88,7 @@ describe('从实际问题建立动作例外', () => {
expect(save).toHaveBeenCalledExactlyOnceWith('candidate-project', { ...latest, actionExceptions: [
policy.actionExceptions![0],
{ code: 'action_resource_conflict', ownerRef: '@CH0001', resource: 'left_hand', reason: '剧本明确允许左手同时挥动持物' }
] })
] }, 2)
expect(wrapper.emitted('refresh')).toHaveLength(1)
expect(quality.actionStatus).toBe('blocked')
expect(wrapper.find('textarea').exists()).toBe(false)
@@ -95,8 +96,8 @@ describe('从实际问题建立动作例外', () => {
it('保存前出现活动任务或切换检查点时,不提交旧问题的例外', async () => {
const { state, quality } = conflict()
let finish!: (value: { projectId: string; policy: ProjectQualityPolicy }) => void
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({ projectId: 'candidate-project', policy })
let finish!: (value: ReturnType<typeof policyReceipt>) => void
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('candidate-project', policy))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
wrapper = mount(ActionExceptionRepair, { props: { projectId: 'candidate-project', checkpointId: 'candidate-current', state, quality, disabled: false } })
await flushPromises()
@@ -105,7 +106,7 @@ describe('从实际问题建立动作例外', () => {
read.mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
await wrapper.findAll('button').find(button => button.text() === '保存动作例外')!.trigger('click')
await wrapper.setProps({ disabled: true })
finish({ projectId: 'candidate-project', policy })
finish(policyReceipt('candidate-project', policy))
await flushPromises()
expect(save).not.toHaveBeenCalled()
expect(wrapper.find('textarea').element.value).toBe('允许原因')
@@ -117,7 +118,7 @@ describe('从实际问题建立动作例外', () => {
it('已有同一角色部位的例外不重复添加,其他例外保持可见', async () => {
const { state, quality } = conflict()
const existing = { ...policy, actionExceptions: [...policy.actionExceptions!, { code: 'action_resource_conflict' as const, ownerRef: '@CH0001', resource: 'left_hand' as const, reason: '已确认的同类例外' }] }
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({ projectId: 'candidate-project', policy: existing })
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('candidate-project', existing))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
wrapper = mount(ActionExceptionRepair, { props: { projectId: 'candidate-project', checkpointId: 'candidate-current', state, quality, disabled: false } })
await flushPromises()
@@ -129,7 +130,7 @@ describe('从实际问题建立动作例外', () => {
it('保存失败保留原因供修正,不增加本地例外或宣称已通过', async () => {
const { state, quality } = conflict()
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({ projectId: 'candidate-project', policy })
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('candidate-project', policy))
vi.spyOn(projectsApi, 'saveQualityPolicy').mockRejectedValue(new Error('后端拒绝修改'))
wrapper = mount(ActionExceptionRepair, { props: { projectId: 'candidate-project', checkpointId: 'candidate-current', state, quality, disabled: false } })
await flushPromises()
@@ -146,7 +147,7 @@ describe('从实际问题建立动作例外', () => {
it('读取失败或项目不符时不使用默认规则、不开放添加', async () => {
const { state, quality } = conflict()
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue({ projectId: 'other', policy })
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('other', policy))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
wrapper = mount(ActionExceptionRepair, { props: { projectId: 'candidate-project', checkpointId: 'candidate-current', state, quality, disabled: false } })
await flushPromises()
@@ -0,0 +1,83 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, DOMWrapper, type VueWrapper } from '@vue/test-utils'
import StoryboardDiagnosis from '@/features/breakdown/components/StoryboardDiagnosis.vue'
import DiagnosisShotDetails from '@/features/breakdown/components/DiagnosisShotDetails.vue'
import { preparationApi } from '@/features/storyboard-preparation/api'
import { breakdownApi } from '@/features/breakdown/api'
import { workflowExecutionApi } from '@/features/workflows/execution-api'
import { diagnosisCanStart } from '@/features/breakdown/diagnosis'
import type { DiagnosisPreflight } from '@/features/breakdown/diagnosis.types'
/** 当前正式镜头的免费来源检查。 */
const checked = (): DiagnosisPreflight => ({ projectId: 'diag-p', shotId: 'db-shot', episodeNo: 1, beatNo: 1, shotNo: 1, policyRevision: 3, policyFingerprint: 'a'.repeat(64), existingDiagnosisId: null, existingValid: false, eligibleForFurtherValidation: true, errors: [], requiresExecutionValidation: true, shouldDiagnose: true, willCallModel: false, willModifyAssets: false })
let wrapper: VueWrapper | undefined
/** 最近范围的真实形状,不包含可用于编辑的完整动作字段。 */
const preview = () => ({ projectId: 'diag-p', episodeNo: 1, candidateCount: 1, needsEvidenceCount: 1, invalidSnapshotCount: 0, candidates: [{ shotId: 'db-shot', episodeNo: 1, beatNo: 1, shotNo: 1, title: '当前镜头', description: '原始描述', durationSeconds: 4, requiredActionCount: 2, hasDurationPlanning: true, hasHandOccupancy: true, status: 'has_evidence' as const }], willCallModel: false as const, willModifyAssets: false as const })
/** 只读接口全部隔离,任何未授权模型请求均由测试捕获。 */
function mocks() {
vi.spyOn(workflowExecutionApi, 'latest').mockResolvedValue(null)
vi.spyOn(breakdownApi, 'legacyActionDiagnosisResults').mockResolvedValue({ projectId: 'diag-p', episodeNo: 1, counts: { total: 0, conflict: 0, clear: 0, insufficient: 0, invalid: 0, stale: 0, pending: 0 }, shots: [] })
vi.spyOn(breakdownApi, 'handOccupancyDiagnostics').mockResolvedValue({ projectId: 'diag-p', shotCount: 0, diagnostics: [] } as never)
vi.spyOn(breakdownApi, 'legacyActionDiagnosisPreview').mockImplementation(async () => preview())
return vi.spyOn(breakdownApi, 'startLegacyActionDiagnosis')
}
beforeEach(() => { vi.spyOn(preparationApi, 'revisions').mockResolvedValue({ projectId: 'diag-p', shotId: 'db-shot', count: 0, revisions: [] }) })
afterEach(() => { wrapper?.unmount(); wrapper = undefined; vi.restoreAllMocks(); vi.unstubAllGlobals(); document.body.innerHTML = '' })
describe('单镜头诊断收费前来源检查', () => {
it('规则缺失、跨项目、已可复用和不完整检查都不能进入新诊断', () => {
expect(diagnosisCanStart(checked(), 'diag-p', 'db-shot')).toBe(true)
for (const invalid of [{ projectId: 'other' }, { shotId: 'other' }, { existingValid: true }, { shouldDiagnose: false }, { policyRevision: null }, { policyFingerprint: null }, { errors: ['QUALITY_POLICY_SNAPSHOT_UNKNOWN'] }, { eligibleForFurtherValidation: false }])
expect(diagnosisCanStart({ ...checked(), ...invalid }, 'diag-p', 'db-shot')).toBe(false)
})
it('正式单镜头入口先预检查,缺少规则快照显示中文原因且不发收费请求', async () => {
const start = mocks()
const read = vi.spyOn(breakdownApi, 'diagnosisPreflight').mockResolvedValue({ ...checked(), shouldDiagnose: false, eligibleForFurtherValidation: false, errors: ['QUALITY_POLICY_SNAPSHOT_UNKNOWN'] })
wrapper = mount(StoryboardDiagnosis, { attachTo: document.body, props: { projectId: 'diag-p', episodeNo: 1, episodeNos: [1] } })
wrapper.getComponent(StoryboardDiagnosis).vm.open({ episodeNo: 1, beatNo: 1, shotNo: 1 }); await flushPromises()
expect(read).toHaveBeenCalledWith('diag-p', 'db-shot')
const drawer = new DOMWrapper(document.querySelector('[aria-label="动作诊断"]')!)
expect(drawer.text()).toContain('缺少可信的质量规则记录')
expect(drawer.get('[aria-label="启动 AI 诊断"]').attributes('disabled')).toBeDefined()
expect(start).not.toHaveBeenCalled()
})
it('费用确认后再次检查,规则变化时保留只读结果并撤销启动', async () => {
const start = mocks()
vi.spyOn(breakdownApi, 'diagnosisPreflight').mockResolvedValueOnce(checked()).mockResolvedValue({ ...checked(), policyRevision: 4, policyFingerprint: 'b'.repeat(64) })
wrapper = mount(StoryboardDiagnosis, { attachTo: document.body, props: { projectId: 'diag-p', episodeNo: 1, episodeNos: [1] } })
wrapper.getComponent(StoryboardDiagnosis).vm.open({ episodeNo: 1, beatNo: 1, shotNo: 1 }); await flushPromises()
await new DOMWrapper(document.querySelector('[aria-label="动作诊断"]')!).get('[aria-label="启动 AI 诊断"]').trigger('click')
await flushPromises()
const confirmation = new DOMWrapper(document.querySelector('.app-dialog')!)
await confirmation.findAll('button').find(button => button.text() === '确认启动 AI 诊断')!.trigger('click')
await flushPromises()
expect(start).not.toHaveBeenCalled()
expect(new DOMWrapper(document.querySelector('[aria-label="动作诊断"]')!).get('[aria-label="启动 AI 诊断"]').attributes('disabled')).toBeDefined()
})
it('镜头描述在费用确认期间变化时必须重新预览,不能直接诊断新内容', async () => {
const start = mocks()
vi.spyOn(breakdownApi, 'diagnosisPreflight').mockResolvedValue(checked())
vi.mocked(breakdownApi.legacyActionDiagnosisPreview).mockResolvedValueOnce(preview()).mockResolvedValue({ ...preview(), candidates: [{ ...preview().candidates[0]!, description: '已更改的新镜头' }] })
wrapper = mount(StoryboardDiagnosis, { attachTo: document.body, props: { projectId: 'diag-p', episodeNo: 1, episodeNos: [1] } })
wrapper.getComponent(StoryboardDiagnosis).vm.open({ episodeNo: 1, beatNo: 1, shotNo: 1 }); await flushPromises()
await new DOMWrapper(document.querySelector('[aria-label="动作诊断"]')!).get('[aria-label="启动 AI 诊断"]').trigger('click'); await flushPromises()
await new DOMWrapper(document.querySelector('.app-dialog')!).findAll('button').find(button => button.text() === '确认启动 AI 诊断')!.trigger('click'); await flushPromises()
expect(start).not.toHaveBeenCalled()
})
it('修订条件与历史按需读取,跨项目响应不显示为可修订', async () => {
const history = vi.spyOn(breakdownApi, 'diagnosisHistory').mockResolvedValue({ projectId: 'other', shotId: 'db-shot', count: 0, revisions: [] })
vi.spyOn(breakdownApi, 'diagnosisRepairReadiness').mockResolvedValue({ projectId: 'other', shotId: 'db-shot', diagnosisId: 'd', eligible: true, repairCandidates: [], blockingReasons: [], requiresManualReview: true, canApplyDirectly: false, willCallModel: false, willModifyAssets: false })
wrapper = mount(DiagnosisShotDetails, { props: { projectId: 'diag-p', shot: { shotId: 'db-shot', episodeNo: 1, beatNo: 1, shotNo: 1, title: '镜头', diagnosisId: 'd', status: 'conflict_found', issues: [], createdAt: null } } })
expect(history).not.toHaveBeenCalled()
await wrapper.get('button').trigger('click'); await flushPromises()
expect(wrapper.text()).toContain('记录与当前镜头不一致')
expect(wrapper.text()).not.toContain('已满足人工修订')
})
it('旧诊断即使只读资格返回 eligible,也不能显示成当前可修订', async () => {
vi.spyOn(breakdownApi, 'diagnosisHistory').mockResolvedValue({ projectId: 'diag-p', shotId: 'db-shot', count: 0, revisions: [] })
vi.spyOn(breakdownApi, 'diagnosisRepairReadiness').mockResolvedValue({ projectId: 'diag-p', shotId: 'db-shot', diagnosisId: 'd', eligible: true, repairCandidates: [], blockingReasons: [], requiresManualReview: true, canApplyDirectly: false, willCallModel: false, willModifyAssets: false })
wrapper = mount(DiagnosisShotDetails, { props: { projectId: 'diag-p', shot: { shotId: 'db-shot', episodeNo: 1, beatNo: 1, shotNo: 1, title: '镜头', diagnosisId: 'd', status: 'stale', policyStatus: 'stale', shotStale: false, issues: [], createdAt: null } } })
await wrapper.get('button').trigger('click'); await flushPromises()
expect(wrapper.text()).not.toContain('已满足人工修订')
})
})
@@ -0,0 +1,41 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
import { flushPromises, mount, DOMWrapper, type VueWrapper } from '@vue/test-utils'
import StoryboardDiagnosis from '@/features/breakdown/components/StoryboardDiagnosis.vue'
import WorkflowExecutionPanel from '@/features/workflows/WorkflowExecutionPanel.vue'
import { breakdownApi } from '@/features/breakdown/api'
import type { LegacyActionDiagnosisResults } from '@/features/breakdown/types'
import type { WorkflowExecution } from '@/features/workflows/execution.types'
/** 页面回执同时包含修订完成、局部证据不足和 AI 待复查。 */
const shot: LegacyActionDiagnosisResults['shots'][number] = { shotId: 'shot-1', episodeNo: 1, beatNo: 1, shotNo: 1, title: '捂耳取铃', diagnosisId: 'diag-1', status: 'stale' as const, issues: [], createdAt: null,
policyStatus: 'stale', shotStale: true, repairStatus: 'repaired', requiresPostRepairDiagnosis: true,
handAudit: { status: 'partial_evidence', evidenceCount: 1, expectedActionCount: 2, coveredActionCount: 1, issueCount: 0, coverage: 0.5 },
bodyMotionFindings: [{ dimension: 'balance', status: 'needs_review', description: '重心需要核对', quote: '单脚站立' }] }
let wrapper: VueWrapper | undefined
afterEach(() => { wrapper?.unmount(); wrapper = undefined; vi.restoreAllMocks(); vi.unstubAllGlobals(); document.body.innerHTML = '' })
describe('诊断版本及复查展示', () => {
it('修订完成不显示全部通过,展示规则和镜头过期、手部覆盖及全身疑点', async () => {
vi.spyOn(breakdownApi, 'legacyActionDiagnosisResults').mockResolvedValue({ projectId: 'diag-update', episodeNo: 1, counts: { total: 1, conflict: 0, clear: 0, insufficient: 0, invalid: 0, stale: 1, pending: 0 }, shots: [shot] })
vi.spyOn(breakdownApi, 'handOccupancyDiagnostics').mockResolvedValue({ projectId: 'diag-update', shotCount: 1, evidenceShotCount: 0, diagnostics: [] } as never)
wrapper = mount(StoryboardDiagnosis, { attachTo: document.body, props: { projectId: 'diag-update', episodeNo: 1, episodeNos: [1] } })
await flushPromises(); await wrapper.get('button').trigger('click'); await flushPromises()
const dialog = new DOMWrapper(document.querySelector('[aria-label="动作诊断"]')!)
expect(dialog.text()).toContain('镜头已修订,AI 待复查')
expect(dialog.text()).toContain('镜头内容已变化')
expect(dialog.text()).toContain('质量规则已变化')
expect(dialog.text()).toContain('手部动作证据 1 / 2')
expect(dialog.text()).toContain('重心需要核对')
expect(dialog.text()).not.toContain('全部通过')
})
it('中断诊断显示人工核查与可复用数量,不把未匹配镜头描述为未计费', () => {
const execution = { id: 'task', projectId: 'p', workflowName: 'storyboard-legacy-action-diagnosis', status: 'failed', current: 1, total: 3,
result: { recoveryRequired: true, retryAutomatically: false, requiresManualReview: true, resumeMode: 'manual', reusableShotCount: 1, manualReviewShotCount: 2, scopedShotCount: 3, qualityPolicyVerified: true }, metadata: null, stage: 'interrupted', currentResourceId: null, error: '诊断中断', startedAt: null, completedAt: null, createdAt: '', updatedAt: '' } satisfies WorkflowExecution
wrapper = mount(WorkflowExecutionPanel, { props: { execution, loading: false, error: '' } })
expect(wrapper.text()).toContain('需要人工核查')
expect(wrapper.text()).toContain('可复用 1 镜')
expect(wrapper.text()).toContain('待核查 2 镜')
expect(wrapper.text()).toContain('可能已产生费用')
expect(wrapper.text()).not.toContain('未计费')
})
})
@@ -0,0 +1,43 @@
import { effectScope, ref } from 'vue'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { projectsApi } from '@/features/projects/api'
import { useBreakdownStartPolicy } from '@/features/breakdown/useBreakdownStartPolicy'
import { candidatePreviewReady } from '@/features/breakdown/candidate'
import { policyReceipt } from '../../fixtures/quality-policy'
import { commitPreview } from '../../fixtures/breakdown-candidate'
/** 当前规则;格式版本不能代替服务修订版本。 */
const policy = { version: 1 as const, physicsMode: 'realistic' as const, allowExaggeratedMotion: false, allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: [] }
afterEach(() => { vi.restoreAllMocks(); vi.unstubAllGlobals(); localStorage.clear() })
describe('服务端规则确认契约', () => {
it('保存发送规则和期望修订,明确确认使用独立接口', async () => {
const fetcher = vi.fn<typeof fetch>().mockImplementation(async () => new Response(JSON.stringify({ data: policyReceipt('p', policy) })))
vi.stubGlobal('fetch', fetcher)
await projectsApi.saveQualityPolicy('p', policy, 2)
expect(JSON.parse(String(fetcher.mock.calls[0]?.[1]?.body))).toEqual({ policy, expectedRevision: 2 })
await projectsApi.confirmQualityPolicy('p', 2)
expect(fetcher.mock.calls[1]?.[0]).toBe('/api/projects/p/quality-policy/confirm')
expect(JSON.parse(String(fetcher.mock.calls[1]?.[1]?.body))).toEqual({ expectedRevision: 2 })
})
it('服务已确认的规则跨浏览器直接进入费用确认,启动携带真实修订版本', async () => {
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(policyReceipt('p', policy, { confirmed: true, confirmedRevision: 2, confirmedAt: '2026-10-17T15:00:00Z' }))
const scope = effectScope()
try {
const flow = scope.run(() => useBreakdownStartPolicy(ref('p'), ref('scope'), ref(true)))!
await flow.prepare()
expect(flow.reviewOpen.value).toBe(false)
expect(flow.startOpen.value).toBe(true)
expect(await flow.verifyStart()).toBe(true)
expect(flow.consumePermit()).toEqual({ expectedRevision: 2 })
expect(flow.consumePermit()).toBeNull()
} finally { scope.stop() }
})
it('候选安全检查必须包含规则匹配,缺失或 false 均不可提交', () => {
const preview = commitPreview()
expect(candidatePreviewReady({ ...preview, checks: { ...preview.checks, qualityPolicyMatches: false } }, preview.projectId, preview.checkpointId)).toBe(false)
const missing = structuredClone(preview)
delete (missing.checks as Partial<typeof missing.checks>).qualityPolicyMatches
expect(candidatePreviewReady(missing, preview.projectId, preview.checkpointId)).toBe(false)
})
})
+105 -232
View File
@@ -1,261 +1,134 @@
import { effectScope, ref, type EffectScope } from 'vue'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { projectsApi } from '@/features/projects/api'
import type { ProjectQualityPolicy, ProjectQualityPolicyResult } from '@/features/projects/types'
import type { ProjectQualityPolicyResult } from '@/features/projects/types'
import { policyDraft } from '@/features/projects/quality-policy'
import { useBreakdownStartPolicy } from '@/features/breakdown/useBreakdownStartPolicy'
import {
invalidateQualityPolicyConfirmation, qualityPolicySignature,
readQualityPolicyConfirmation, rememberQualityPolicyConfirmation
} from '@/features/projects/quality-policy-confirmation'
import { qualityPolicySignature } from '@/features/projects/quality-policy-confirmation'
import { policyReceipt } from '../../fixtures/quality-policy'
/**
* 使用真实接口形状的独立规则,不连接服务或调用模型。
* @returns 独立项目规则回执
*/
function receipt(): ProjectQualityPolicyResult {
return { projectId: 'policy-project', policy: {
version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false,
allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: []
} }
}
/** 每个测试释放组合函数观察器。 */
let scope: EffectScope | undefined
/**
* 创建可切换项目、预览和活动锁的测试观察器。
* @returns 流程及其响应式输入
*/
/** 真实规则回执,旧项目初始修订也必须明确确认。 */
const initial = () => policyReceipt('policy-project', {
version: 1, physicsMode: 'realistic', allowExaggeratedMotion: false,
allowNonPhysicalActions: false, allowSupernaturalAbilities: false, customRules: []
}, { revision: 0 })
/** 测试结束释放全部流程观察器。 */
const scopes: EffectScope[] = []
/** 创建独立流程,不访问真实模型。 */
function setup() {
const id = ref('policy-project')
const input = ref('preview-1')
const allowed = ref(true)
scope = effectScope()
const flow = scope.run(() => useBreakdownStartPolicy(id, input, allowed))!
return { id, input, allowed, flow }
const id = ref('policy-project'), input = ref('preview-1'), allowed = ref(true)
const scope = effectScope(); scopes.push(scope)
return { id, input, allowed, flow: scope.run(() => useBreakdownStartPolicy(id, input, allowed))! }
}
afterEach(() => {
scope?.stop()
vi.unstubAllGlobals()
localStorage.clear()
vi.restoreAllMocks()
})
/** 模拟服务端 CAS 保存及独立明确确认,复制回执避免测试污染。 */
function server() {
let saved = initial()
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => structuredClone(saved))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(async (_id, policy, expected) => {
if (expected !== saved.revision) throw new Error('版本冲突')
saved = policyReceipt(saved.projectId, policyDraft(policy), { revision: saved.revision + 1, fingerprint: 'b'.repeat(64) })
return structuredClone(saved)
})
const confirm = vi.spyOn(projectsApi, 'confirmQualityPolicy').mockImplementation(async (_id, expected) => {
if (expected !== saved.revision) throw new Error('版本冲突')
saved = { ...saved, confirmed: true, confirmedRevision: expected, confirmedAt: '2026-10-17T15:00:00Z' }
return structuredClone(saved)
})
return { read, save, confirm, get: () => saved, change: (value: Partial<ProjectQualityPolicyResult>) => { saved = { ...saved, ...value } } }
}
afterEach(() => { scopes.splice(0).forEach(scope => scope.stop()); vi.restoreAllMocks(); vi.unstubAllGlobals(); localStorage.clear() })
describe('拆解质量规则内容与当前浏览器确认', () => {
it('忽略属性顺序、首尾空格和空例外表示,但识别许可、规则和例外的实际变化', () => {
const base = receipt().policy
describe('规则内容比较与服务端确认', () => {
it('格式版本不代替修订,比较内容时保留许可、规则和例外变化', () => {
const base = initial().policy
expect(qualityPolicySignature({ ...base, actionExceptions: [] })).toBe(qualityPolicySignature(base))
const reversed = Object.fromEntries(Object.entries({ ...base, customRules: ['规则'] }).toReversed()) as unknown as ProjectQualityPolicy
expect(qualityPolicySignature({ ...base, customRules: [' 规则 '] })).toBe(qualityPolicySignature(reversed))
for (const changed of [
{ ...base, physicsMode: 'fantasy' as const },
{ ...base, allowExaggeratedMotion: true },
{ ...base, allowNonPhysicalActions: true },
{ ...base, allowSupernaturalAbilities: true },
{ ...base, customRules: ['新规则'] },
{ ...base, actionExceptions: [{ code: 'action_resource_conflict' as const, ownerRef: '@CH1', resource: 'left_hand' as const, reason: '剧本许可' }] }
]) expect(qualityPolicySignature(changed)).not.toBe(qualityPolicySignature(base))
expect(() => qualityPolicySignature({ ...base, customRules: null } as unknown as ProjectQualityPolicy)).toThrow('质量规则响应不完整')
expect(qualityPolicySignature({ ...base, customRules: [' 规则 '] })).toBe(qualityPolicySignature({ ...base, customRules: ['规则'] }))
for (const change of [{ physicsMode: 'fantasy' as const }, { allowExaggeratedMotion: true }, { allowNonPhysicalActions: true }, { allowSupernaturalAbilities: true }, { customRules: ['新规则'] }, { actionExceptions: [{ code: 'action_resource_conflict' as const, ownerRef: '@CH1', resource: 'left_hand' as const, reason: '许可' }] }])
expect(qualityPolicySignature({ ...base, ...change })).not.toBe(qualityPolicySignature(base))
})
it('确认按项目隔离,损坏存储或存储权限失败不会被当作已确认', () => {
expect(readQualityPolicyConfirmation('policy-project')).toBeNull()
rememberQualityPolicyConfirmation('policy-project', 'signature')
expect(readQualityPolicyConfirmation('other')).toBeNull()
localStorage.setItem('short-drama:breakdown-quality-confirmation:v1:policy-project', '{')
expect(readQualityPolicyConfirmation('policy-project')).toBeNull()
vi.stubGlobal('localStorage', { getItem: () => null, setItem: () => { throw new Error('storage blocked') } })
expect(rememberQualityPolicyConfirmation('policy-project', 'new')).toBe(false)
it('旧浏览器确认记录不能跳过服务未确认规则;取消不写入确认', async () => {
const api = server()
localStorage.setItem('short-drama:breakdown-quality-confirmation:v1:policy-project', JSON.stringify({ formatVersion: 1, signature: qualityPolicySignature(initial().policy) }))
const { flow } = setup(); await flow.prepare()
expect(flow.reviewOpen.value).toBe(true); expect(flow.startOpen.value).toBe(false)
flow.cancel(); expect(api.confirm).not.toHaveBeenCalled(); expect(flow.consumePermit()).toBeNull()
})
})
describe('拆解前规则确认流程', () => {
it('首次读取失败不展示默认规则,重试后才能进入确认', async () => {
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockRejectedValueOnce(new Error('读取不可用')).mockResolvedValue(receipt())
const { flow } = setup()
await flow.prepare()
expect(flow.policy.value).toBeNull()
expect(flow.reviewOpen.value).toBe(false)
expect(flow.startOpen.value).toBe(false)
expect(flow.error.value).toBe('读取不可用')
expect(flow.consumePermit()).toBe(false)
await flow.prepare()
expect(read).toHaveBeenCalledTimes(2)
expect(flow.reviewOpen.value).toBe(true)
expect(flow.error.value).toBe('')
})
it('首次读取真实规则,取消不记录确认,也不允许绕过确认直接启动', async () => {
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(receipt())
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
const { flow } = setup()
expect(read).not.toHaveBeenCalled()
await flow.prepare()
expect(flow.reviewOpen.value).toBe(true)
expect(flow.startOpen.value).toBe(false)
expect(await flow.verifyStart()).toBe(false)
expect(flow.consumePermit()).toBe(false)
flow.cancel()
expect(readQualityPolicyConfirmation('policy-project')).toBeNull()
expect(save).not.toHaveBeenCalled()
})
it('明确确认未改规则不重复保存,刷新会话后直接进入普通启动确认', async () => {
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(receipt())
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
const { flow } = setup()
await flow.prepare()
expect(await flow.confirmRules(receipt().policy)).toBe(true)
expect(flow.startOpen.value).toBe(true)
expect(save).not.toHaveBeenCalled()
expect(flow.consumePermit()).toBe(false)
flow.cancel()
scope!.stop()
const next = setup().flow
await next.prepare()
expect(next.reviewOpen.value).toBe(false)
expect(next.startOpen.value).toBe(true)
it('未改规则也独立明确确认,修订零可启动,其他页面重进不重复提醒', async () => {
const api = server(); const { flow } = setup()
await flow.prepare(); expect(await flow.confirmRules(initial().policy)).toBe(true)
expect(api.save).not.toHaveBeenCalled(); expect(api.confirm).toHaveBeenCalledExactlyOnceWith('policy-project', 0)
flow.cancel(); const next = setup().flow; await next.prepare()
expect(next.reviewOpen.value).toBe(false); expect(next.startOpen.value).toBe(true)
expect(await next.verifyStart()).toBe(true)
expect(next.consumePermit()).toBe(true)
expect(next.consumePermit()).toBe(false)
expect(next.consumePermit()).toEqual({ expectedRevision: 0 }); expect(next.consumePermit()).toBeNull()
})
it('编辑的完整草稿先保存并重读,保存后的内容才记作已确认', async () => {
const saved = receipt()
const draft = { ...saved.policy, allowExaggeratedMotion: true }
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => structuredClone(saved))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(async (id, policy) => {
saved.policy = policyDraft(policy)
return { projectId: id, policy: policyDraft(policy) }
})
const { flow } = setup()
await flow.prepare()
it('修改规则先携带旧修订保存,再确认新修订,最后重读确认', async () => {
const api = server(); const { flow } = setup(); await flow.prepare()
const draft = { ...initial().policy, allowExaggeratedMotion: true }
expect(await flow.confirmRules(draft)).toBe(true)
expect(save).toHaveBeenCalledWith('policy-project', draft)
expect(read).toHaveBeenCalledTimes(3)
expect(readQualityPolicyConfirmation('policy-project')).toBe(qualityPolicySignature(draft))
expect(api.save).toHaveBeenCalledExactlyOnceWith('policy-project', draft, 0)
expect(api.confirm).toHaveBeenCalledExactlyOnceWith('policy-project', 1)
expect(api.read).toHaveBeenCalledTimes(3)
expect(await flow.verifyStart()).toBe(true); expect(flow.consumePermit()).toEqual({ expectedRevision: 1 })
})
it('规则在其他位置更新后重新确认,不覆盖服务端较新规则', async () => {
let saved = receipt()
vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => structuredClone(saved))
const save = vi.spyOn(projectsApi, 'saveQualityPolicy')
const { flow } = setup()
await flow.prepare()
saved = { ...saved, policy: { ...saved.policy, allowNonPhysicalActions: true } }
expect(await flow.confirmRules(receipt().policy)).toBe(false)
expect(flow.policy.value?.policy.allowNonPhysicalActions).toBe(true)
expect(flow.reviewOpen.value).toBe(true)
expect(flow.startOpen.value).toBe(false)
expect(save).not.toHaveBeenCalled()
expect(readQualityPolicyConfirmation('policy-project')).toBeNull()
it('同内容被修改后又恢复但修订增加时仍重新确认,不能覆盖更新', async () => {
const api = server(); const { flow } = setup(); await flow.prepare()
api.change({ revision: 4 })
expect(await flow.confirmRules(initial().policy)).toBe(false)
expect(flow.policy.value?.revision).toBe(4); expect(api.save).not.toHaveBeenCalled(); expect(api.confirm).not.toHaveBeenCalled()
})
it('真实保存期间锁定取消,保存后的只读回查可取消,迟到回查不记录确认', async () => {
const initial = receipt()
const draft = { ...initial.policy, allowNonPhysicalActions: true }
let finishSave!: (value: ProjectQualityPolicyResult) => void
let finishRead!: (value: ProjectQualityPolicyResult) => void
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(initial)
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockImplementation(() => new Promise(resolve => { finishSave = resolve }))
const { flow } = setup()
await flow.prepare()
const pending = flow.confirmRules(draft)
await Promise.resolve()
await Promise.resolve()
expect(save).toHaveBeenCalledOnce()
expect(flow.saving.value).toBe(true)
flow.cancel()
expect(flow.reviewOpen.value).toBe(true)
read.mockImplementationOnce(() => new Promise(resolve => { finishRead = resolve }))
finishSave({ ...initial, policy: draft })
await Promise.resolve()
await Promise.resolve()
expect(flow.saving.value).toBe(false)
expect(flow.reading.value).toBe(true)
flow.cancel()
finishRead({ ...initial, policy: draft })
expect(await pending).toBe(false)
expect(flow.reviewOpen.value).toBe(false)
expect(flow.startOpen.value).toBe(false)
expect(readQualityPolicyConfirmation(initial.projectId)).toBeNull()
it.each(['读取失败', '项目不符', '元数据缺失', '保存失败', '确认失败', '回执不符', '确认后变化'])('拦截%s且不取得启动许可', async kind => {
const api = server(); const { flow } = setup(); await flow.prepare()
const draft = { ...initial().policy, allowNonPhysicalActions: true }
if (kind === '读取失败') api.read.mockRejectedValueOnce(new Error('读取失败'))
if (kind === '项目不符') api.read.mockResolvedValueOnce({ ...initial(), projectId: 'other' })
if (kind === '元数据缺失') api.read.mockResolvedValueOnce({ ...initial(), revision: undefined } as unknown as ProjectQualityPolicyResult)
if (kind === '保存失败') api.save.mockRejectedValueOnce(new Error('保存失败'))
if (kind === '确认失败') api.confirm.mockRejectedValueOnce(new Error('确认失败'))
if (kind === '回执不符') api.confirm.mockResolvedValueOnce(initial())
if (kind === '确认后变化') api.confirm.mockImplementationOnce(async () => {
const confirmed = { ...api.get(), confirmed: true, confirmedRevision: api.get().revision, confirmedAt: '2026-10-17T15:00:00Z' }
api.change({ revision: api.get().revision + 1 }); return confirmed
})
expect(await flow.confirmRules(draft)).toBe(false); expect(flow.startOpen.value).toBe(false); expect(flow.consumePermit()).toBeNull()
})
it('最终启动确认期间规则变化,返回规则界面并撤销启动许可', async () => {
const saved = receipt()
vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(async () => structuredClone(saved))
rememberQualityPolicyConfirmation(saved.projectId, qualityPolicySignature(saved.policy))
const { flow } = setup()
await flow.prepare()
saved.policy.customRules = ['新规则']
expect(await flow.verifyStart()).toBe(false)
expect(flow.reviewOpen.value).toBe(true)
expect(flow.startOpen.value).toBe(false)
expect(flow.consumePermit()).toBe(false)
})
it.each(['读取失败', '项目不符', '保存失败', '回执不符', '保存后变化'])('安全拦截%s,不记住确认', async kind => {
const initial = receipt()
const changed = { ...initial.policy, allowNonPhysicalActions: true }
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(initial)
const save = vi.spyOn(projectsApi, 'saveQualityPolicy').mockResolvedValue({ ...initial, policy: changed })
const { flow } = setup()
await flow.prepare()
if (kind === '读取失败') read.mockRejectedValueOnce(new Error('读取失败'))
if (kind === '项目不符') read.mockResolvedValueOnce({ ...initial, projectId: 'other' })
if (kind === '保存失败') save.mockRejectedValueOnce(new Error('保存失败'))
if (kind === '回执不符') save.mockResolvedValueOnce(initial)
expect(await flow.confirmRules(changed)).toBe(false)
expect(flow.reviewOpen.value).toBe(true)
expect(flow.startOpen.value).toBe(false)
expect(flow.consumePermit()).toBe(false)
expect(readQualityPolicyConfirmation(initial.projectId)).toBeNull()
})
it.each(['cancel', 'project', 'scope', 'locked'])('重复点击只读一次,%s 后丢弃迟到读取', async cause => {
it.each(['cancel', 'project', 'scope', 'locked'])('%s 后丢弃迟到读取,重复点击不重复读取', async cause => {
let finish!: (value: ProjectQualityPolicyResult) => void
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockImplementation(() => new Promise(resolve => { finish = resolve }))
const { flow, id, input, allowed } = setup()
const pending = flow.prepare()
await flow.prepare()
const { flow, id, input, allowed } = setup(); const pending = flow.prepare(); await flow.prepare()
expect(read).toHaveBeenCalledTimes(1)
if (cause === 'cancel') flow.cancel()
if (cause === 'project') id.value = 'other'
if (cause === 'scope') input.value = 'preview-2'
if (cause === 'scope') input.value = 'new'
if (cause === 'locked') allowed.value = false
finish(receipt())
await pending
expect(flow.reviewOpen.value).toBe(false)
expect(flow.startOpen.value).toBe(false)
expect(flow.consumePermit()).toBe(false)
finish(initial()); await pending
expect(flow.reviewOpen.value).toBe(false); expect(flow.startOpen.value).toBe(false); expect(flow.consumePermit()).toBeNull()
})
it('最终重读失败不能启动,取消后迟到成功也不能启动', async () => {
const read = vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(receipt())
rememberQualityPolicyConfirmation('policy-project', qualityPolicySignature(receipt().policy))
const { flow } = setup()
await flow.prepare()
read.mockRejectedValueOnce(new Error('重读失败'))
expect(await flow.verifyStart()).toBe(false)
expect(flow.consumePermit()).toBe(false)
it('确认写入时锁定取消,写入后的只读回查仍可关闭且迟到响应不启动', async () => {
const api = server(); const { flow } = setup(); await flow.prepare()
let finish!: (value: ProjectQualityPolicyResult) => void
read.mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
const pending = flow.verifyStart()
flow.cancel()
finish(receipt())
expect(await pending).toBe(false)
expect(flow.consumePermit()).toBe(false)
api.confirm.mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
const pending = flow.confirmRules(initial().policy)
await Promise.resolve(); await Promise.resolve(); expect(flow.saving.value).toBe(true)
flow.cancel(); expect(flow.reviewOpen.value).toBe(true)
let finishRead!: (value: ProjectQualityPolicyResult) => void
api.read.mockImplementationOnce(() => new Promise(resolve => { finishRead = resolve }))
const confirmed = { ...initial(), confirmed: true, confirmedRevision: 0, confirmedAt: '2026-10-17T15:00:00Z' }
finish(confirmed); await Promise.resolve(); await Promise.resolve()
expect(flow.reading.value).toBe(true); expect(flow.saving.value).toBe(false)
flow.cancel(); finishRead(confirmed); expect(await pending).toBe(false); expect(flow.consumePermit()).toBeNull()
})
it('存储受限时仅在本次会话跳过确认,实际规则保存会撤销临时确认', async () => {
vi.stubGlobal('localStorage', { getItem: () => null, removeItem: () => {}, setItem: () => { throw new Error('blocked') } })
vi.spyOn(projectsApi, 'qualityPolicy').mockResolvedValue(receipt())
const { flow } = setup()
await flow.prepare()
expect(await flow.confirmRules(receipt().policy)).toBe(true)
flow.cancel()
await flow.prepare()
expect(flow.startOpen.value).toBe(true)
invalidateQualityPolicyConfirmation('policy-project')
expect(await flow.verifyStart()).toBe(false)
expect(flow.reviewOpen.value).toBe(true)
it('最终费用确认期间规则更新或确认撤销均返回规则核对', async () => {
const api = server(); const { flow } = setup(); await flow.prepare(); await flow.confirmRules(initial().policy)
api.change({ confirmed: false, confirmedRevision: null, confirmedAt: null })
expect(await flow.verifyStart()).toBe(false); expect(flow.reviewOpen.value).toBe(true); expect(flow.consumePermit()).toBeNull()
})
it('最终重读失败不能启动,取消后迟到成功也不能启动', async () => {
const api = server(); const { flow } = setup(); await flow.prepare(); await flow.confirmRules(initial().policy)
api.read.mockRejectedValueOnce(new Error('重读失败')); expect(await flow.verifyStart()).toBe(false)
let finish!: (value: ProjectQualityPolicyResult) => void
api.read.mockImplementationOnce(() => new Promise(resolve => { finish = resolve }))
const pending = flow.verifyStart(); flow.cancel(); finish(api.get())
expect(await pending).toBe(false); expect(flow.consumePermit()).toBeNull()
})
})