350 lines
15 KiB
TypeScript
350 lines
15 KiB
TypeScript
import { defineComponent, h, ref } from 'vue'
|
|
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
|
|
import { afterEach, describe, expect, it, vi } from 'vitest'
|
|
import { useMotionRevision } from '@/features/storyboard/useMotionRevision'
|
|
import { motionEvidenceCurrent, type MotionPlan, type MotionRevision } from '@/features/storyboard/motion-revision'
|
|
import type { WorkflowExecution } from '@/features/workflows/execution.types'
|
|
import { keyframeFixture } from '@/features/production/testing/fixtures'
|
|
|
|
/** 独立项目避免共享工作流或操作锁互相影响。 */ let serial = 0
|
|
/** 释放所有观察器。 */ const wrappers: VueWrapper[] = []
|
|
afterEach(() => {
|
|
wrappers.splice(0).forEach(wrapper => wrapper.unmount())
|
|
localStorage.clear()
|
|
})
|
|
/**
|
|
* 全量隔离原Task、失败根、人工子版本及起点任务,不调用真实模型。
|
|
* @param conflict 是否拒绝第一次保存
|
|
* @returns 真实编排、公开投影及Mock请求
|
|
*/
|
|
async function harness(conflict = false) {
|
|
const projectId = 'failed-motion-' + ++serial,
|
|
shotId = 'failed-motion-shot',
|
|
primary = keyframeFixture({ shotId })
|
|
const plan: MotionPlan = {
|
|
beats: [
|
|
{
|
|
startSecond: 0,
|
|
endSecond: 4,
|
|
action: '人物开始向前缓慢行走',
|
|
cameraMotion: '保持静止',
|
|
physicalContinuity: '双脚支撑保持正常连续',
|
|
subjectRefs: ['@CH0001'],
|
|
closingState: '人物停在原地保持站立',
|
|
performedActionIds: ['actual-action']
|
|
}
|
|
],
|
|
globalMotionConstraints: ['保持正式动作不重复'],
|
|
interactions: []
|
|
}
|
|
const history: {
|
|
shotId: string
|
|
originalRevisionId: string | null
|
|
activeRevisionId: string | null
|
|
revisions: MotionRevision[]
|
|
} = { shotId, originalRevisionId: null, activeRevisionId: null, revisions: [] }
|
|
const candidate = {
|
|
taskId: 'failed-task',
|
|
executionId: 'failed-workflow',
|
|
shotId,
|
|
plan: { projectId },
|
|
current: true,
|
|
status: 'failed',
|
|
qualityFailure: { phase: 'motion_plan', issues: ['原起点动作冲突'] },
|
|
observations: { motion_plan: plan },
|
|
steps: [
|
|
{
|
|
name: 'motion_plan',
|
|
status: 'completed',
|
|
providerRequestId: 'original-provider',
|
|
usage: { inputTokens: 100 }
|
|
}
|
|
]
|
|
}
|
|
const fetcher = vi.fn<typeof fetch>(async (url, init) => {
|
|
const path = String(url),
|
|
body = init?.body ? JSON.parse(String(init.body)) : undefined
|
|
if (path.endsWith('/motion-plan/preview'))
|
|
return Response.json({
|
|
data: {
|
|
shotId,
|
|
episodeNo: 1,
|
|
beatNo: 1,
|
|
shotNo: 1,
|
|
durationSeconds: 4,
|
|
motionPlanAvailable: false,
|
|
beats: [],
|
|
globalMotionConstraints: [],
|
|
issues: [],
|
|
actionDensityIssues: [],
|
|
actionReviewSuggestions: [],
|
|
savedActionDensityIssues: null,
|
|
willCallModel: false,
|
|
willModifyAssets: false
|
|
}
|
|
})
|
|
if (path.endsWith('/keyframes')) return Response.json({ data: [primary] })
|
|
if (path.endsWith('/video-prompt/executions/failed-task')) return Response.json({ data: candidate })
|
|
if (path.endsWith('/revisions/preview'))
|
|
return Response.json({
|
|
data: {
|
|
shotId,
|
|
valid: true,
|
|
motionPlanFingerprint: 'f'.repeat(64),
|
|
schemaIssues: [],
|
|
timelineIssues: [],
|
|
actionDensityIssues: [],
|
|
formalIssues: [],
|
|
requiresStartStateValidation: true,
|
|
canActivate: false,
|
|
willCallModel: false,
|
|
willModifyAssets: false,
|
|
startStateStatus: 'required_unknown',
|
|
sourceFingerprint: 'c'.repeat(64),
|
|
previewFingerprint: 'd'.repeat(64),
|
|
source: {
|
|
projectId,
|
|
activeRevisionId: history.activeRevisionId,
|
|
primaryKeyframeId: primary.id,
|
|
facts: {}
|
|
},
|
|
startStatePlan: {
|
|
version: 1,
|
|
primaryKeyframeId: primary.id,
|
|
expectedRevisionId: history.activeRevisionId,
|
|
motionPlanFingerprint: 'f'.repeat(64),
|
|
fingerprint: 'a'.repeat(64),
|
|
sourceFingerprint: 'c'.repeat(64),
|
|
status: 'ready',
|
|
executionAvailable: true,
|
|
proposedMaximumProviderRequests: 1,
|
|
additionalProviderRequests: 1,
|
|
feeEstimate: { currency: 'CNY', amount: null, reason: '未知' }
|
|
}
|
|
}
|
|
})
|
|
if (path.endsWith('/revisions') && init?.method === 'POST') {
|
|
if (conflict)
|
|
return Response.json({ code: 'MOTION_PLAN_PREVIEW_STALE', message: '原来源已变化' }, { status: 409 })
|
|
const root: MotionRevision = {
|
|
revisionId: 'failed-root',
|
|
shotId,
|
|
source: 'failed_candidate',
|
|
parentRevisionId: null,
|
|
reason: JSON.stringify({ originalBusinessStatus: 'failed' }),
|
|
candidateOrigin: {
|
|
taskId: 'failed-task',
|
|
workflowExecutionId: 'failed-workflow',
|
|
authorizationId: 'original-grant',
|
|
sourceFingerprint: 'c'.repeat(64),
|
|
evidenceFingerprint: 'e'.repeat(64),
|
|
receiptFingerprint: 'b'.repeat(64),
|
|
originalBusinessStatus: 'failed'
|
|
},
|
|
motionPlan: plan,
|
|
durationSeconds: 4,
|
|
fingerprint: 'e'.repeat(64),
|
|
createdAt: '2026-11-18T00:00:00Z',
|
|
isActive: false
|
|
}
|
|
const manual: MotionRevision = {
|
|
...root,
|
|
revisionId: 'manual-child',
|
|
source: 'manual',
|
|
parentRevisionId: root.revisionId,
|
|
reason: body.reason,
|
|
candidateOrigin: null,
|
|
motionPlan: body.motionPlan,
|
|
fingerprint: 'f'.repeat(64)
|
|
}
|
|
history.revisions = [root, manual]
|
|
return Response.json({ data: manual }, { status: 201 })
|
|
}
|
|
if (path.endsWith('/revisions')) return Response.json({ data: history })
|
|
if (path.endsWith('/start-state-validation/start'))
|
|
return Response.json({
|
|
data: { executionId: 'validation-workflow', status: 'completed', willCallModel: false, reused: true }
|
|
})
|
|
if (path.includes('/workflow-executions/validation-workflow'))
|
|
return Response.json({
|
|
data: {
|
|
id: 'validation-workflow',
|
|
projectId,
|
|
workflowName: 'motion-plan-start-state-validation',
|
|
status: 'completed',
|
|
stage: 'completed',
|
|
current: 1,
|
|
total: 1,
|
|
currentResourceId: null,
|
|
metadata: { shotId, revisionId: 'manual-child' },
|
|
error: null,
|
|
startedAt: null,
|
|
completedAt: null,
|
|
createdAt: '2026-11-18T00:00:00Z',
|
|
updatedAt: '2026-11-18T00:00:00Z',
|
|
result: {
|
|
passed: true,
|
|
stale: false,
|
|
shotId,
|
|
revisionId: 'manual-child',
|
|
fingerprint: 'f'.repeat(64),
|
|
primaryKeyframeId: primary.id,
|
|
primaryKeyframeImageUrl: primary.imageUrl,
|
|
expectedRevisionId: null,
|
|
validation: { passed: true },
|
|
plan: { sourceFingerprint: 'c'.repeat(64), fingerprint: 'a'.repeat(64) }
|
|
}
|
|
}
|
|
})
|
|
if (path.endsWith('/active')) {
|
|
history.activeRevisionId = 'manual-child'
|
|
return Response.json({
|
|
data: {
|
|
shotId,
|
|
activeRevisionId: 'manual-child',
|
|
motionPlanFingerprint: 'f'.repeat(64),
|
|
changed: true,
|
|
videoPromptStale: true
|
|
}
|
|
})
|
|
}
|
|
throw new Error('未模拟 ' + path)
|
|
})
|
|
vi.stubGlobal('fetch', fetcher)
|
|
let state!: ReturnType<typeof useMotionRevision>
|
|
const wrapper = mount(
|
|
defineComponent({
|
|
setup() {
|
|
state = useMotionRevision({ projectId, shotId }, ref(true), () => {})
|
|
return () => h('div')
|
|
}
|
|
})
|
|
)
|
|
wrappers.push(wrapper)
|
|
await flushPromises()
|
|
return { state, history, candidate, fetcher, primary, projectId, shotId }
|
|
}
|
|
describe('失败动作候选只承接为人工子版本', () => {
|
|
it('原Task/Workflow失败保留,预检/保存/起点/采用分别主动执行', async () => {
|
|
const { state, fetcher, history, candidate } = await harness()
|
|
expect(fetcher.mock.calls.every(([, init]) => init?.method === 'GET')).toBe(true)
|
|
expect(state.requiresCandidate.value).toBe(true)
|
|
state.failedTaskId.value = 'failed-task'
|
|
await state.readCandidate()
|
|
expect(state.draft.value.beats).toHaveLength(0)
|
|
state.useCandidate()
|
|
state.draft.value.beats[0]!.action = '人工修订为保持当前站姿后缓慢行走'
|
|
state.reason.value = '只修订原失败动作,不改变身份与场景'
|
|
await state.precheck()
|
|
expect(state.preview.value?.startStateStatus).toBe('required_unknown')
|
|
expect(state.canSave.value).toBe(false)
|
|
state.failedAcknowledged.value = true
|
|
await state.save()
|
|
await flushPromises()
|
|
const save = fetcher.mock.calls.find(
|
|
([url, init]) => String(url).endsWith('/revisions') && init?.method === 'POST'
|
|
)!
|
|
expect(JSON.parse(String(save[1]?.body))).toMatchObject({
|
|
parentRevisionId: null,
|
|
failedCandidate: {
|
|
taskId: 'failed-task',
|
|
expectedSourceFingerprint: 'c'.repeat(64),
|
|
expectedPreviewFingerprint: 'd'.repeat(64),
|
|
acknowledgeFailedCandidate: true
|
|
}
|
|
})
|
|
expect(history.originalRevisionId).toBeNull()
|
|
expect(history.activeRevisionId).toBeNull()
|
|
expect(history.revisions.map(row => row.source)).toEqual(['failed_candidate', 'manual'])
|
|
expect(history.revisions[1]!.parentRevisionId).toBe('failed-root')
|
|
expect(state.candidateOrigin.value?.taskId).toBe('failed-task')
|
|
const preservedDraft = JSON.stringify(state.draft.value)
|
|
state.failedCandidate.value = null
|
|
await state.readOriginCandidate()
|
|
expect(JSON.stringify(state.draft.value)).toBe(preservedDraft)
|
|
expect(state.failedCandidate.value).toMatchObject({ executionId: 'failed-workflow' })
|
|
expect(candidate.status).toBe('failed')
|
|
expect(
|
|
fetcher.mock.calls.some(([url]) => /start-state-validation|\/active$|\/video-prompt$/.test(String(url)))
|
|
).toBe(false)
|
|
state.acknowledged.value = true
|
|
await state.validate()
|
|
expect(fetcher.mock.calls.some(([url]) => String(url).endsWith('/start-state-validation/start'))).toBe(false)
|
|
await state.precheck()
|
|
state.acknowledged.value = true
|
|
await state.validate()
|
|
await flushPromises()
|
|
const start = fetcher.mock.calls.find(([url]) => String(url).endsWith('/start-state-validation/start'))!
|
|
expect(JSON.parse(String(start[1]?.body))).toEqual({
|
|
primaryKeyframeId: state.context.data.value!.primary!.id,
|
|
expectedRevisionId: null,
|
|
expectedPlanFingerprint: 'a'.repeat(64)
|
|
})
|
|
expect(history.activeRevisionId).toBeNull()
|
|
expect(state.canActivate.value).toBe(true)
|
|
await state.activate()
|
|
expect(history.activeRevisionId).toBe('manual-child')
|
|
expect(fetcher.mock.calls.filter(([, init]) => init?.method === 'PUT')).toHaveLength(1)
|
|
})
|
|
it('来源409保留人工草稿,不产生半个版本或自动重试', async () => {
|
|
const { state, fetcher, history } = await harness(true)
|
|
state.failedTaskId.value = 'failed-task'
|
|
await state.readCandidate()
|
|
state.useCandidate()
|
|
state.draft.value.beats[0]!.action = '保留这份人工输入等待重新核对来源'
|
|
state.reason.value = '只保存'
|
|
await state.precheck()
|
|
state.failedAcknowledged.value = true
|
|
await state.save()
|
|
expect(state.draft.value.beats[0]!.action).toBe('保留这份人工输入等待重新核对来源')
|
|
expect(state.preview.value).toBeNull()
|
|
expect(history.revisions).toHaveLength(0)
|
|
expect(
|
|
fetcher.mock.calls.filter(([url, init]) => String(url).endsWith('/revisions') && init?.method === 'POST')
|
|
).toHaveLength(1)
|
|
})
|
|
it('即便伪造通过的起点结果,failed_candidate根也不可直接采用', async () => {
|
|
const { state, fetcher, primary } = await harness()
|
|
state.failedTaskId.value = 'failed-task'
|
|
await state.readCandidate()
|
|
state.useCandidate()
|
|
state.reason.value = '保存测试'
|
|
await state.precheck()
|
|
state.failedAcknowledged.value = true
|
|
await state.save()
|
|
const manual = state.revision.value!
|
|
const execution: WorkflowExecution = {
|
|
stage: null,
|
|
current: 0,
|
|
total: 0,
|
|
currentResourceId: null,
|
|
metadata: null,
|
|
error: null,
|
|
startedAt: null,
|
|
completedAt: null,
|
|
createdAt: '2026-11-18T00:00:00Z',
|
|
updatedAt: '2026-11-18T00:00:00Z',
|
|
id: 'e',
|
|
projectId: 'p',
|
|
workflowName: 'motion-plan-start-state-validation',
|
|
status: 'completed',
|
|
result: {
|
|
passed: true,
|
|
stale: false,
|
|
validation: { passed: true },
|
|
shotId: manual.shotId,
|
|
revisionId: manual.revisionId,
|
|
fingerprint: manual.fingerprint,
|
|
primaryKeyframeId: primary.id,
|
|
primaryKeyframeImageUrl: primary.imageUrl,
|
|
expectedRevisionId: null
|
|
}
|
|
}
|
|
expect(motionEvidenceCurrent(execution, { ...manual, source: 'failed_candidate' }, primary, null)).toBe(false)
|
|
state.select('failed-root')
|
|
await state.precheck()
|
|
expect(state.canValidate.value).toBe(false)
|
|
expect(fetcher.mock.calls.some(([url]) => String(url).endsWith('/active'))).toBe(false)
|
|
})
|
|
})
|