@allbluecn/web-app 0.18.2 → 0.19.0

package/src/server/__tests__/task-context-builder.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, it } from 'vitest'
+import {
+  buildSourceContextBlock,
+  extractTipTapMarkdown,
+} from '@/server/ai-task/context-builder'
+
+// 边界约定：context-builder 是纯函数（row → 文本块），不做源存在性探测、不发查询。
+// 悬空源（lookup 返回 null）由调用方（executor）保证不调用 buildSourceContextBlock。
+
+const TIP_TAP = (markdown: string) =>
+  JSON.stringify({ html: `<p>${markdown}</p>`, markdown })
+
+describe('extractTipTapMarkdown', () => {
+  it('合法 TipTap JSON 字符串 → 取 markdown 段', () => {
+    const desc = TIP_TAP('支持扫码登录')
+    expect(extractTipTapMarkdown(desc)).toBe('支持扫码登录')
+  })
+
+  it('已解析的 TipTap 对象（防御）→ 取 markdown 段', () => {
+    expect(extractTipTapMarkdown({ html: '<p>x</p>', markdown: 'x' })).toBe('x')
+  })
+
+  it('非法 JSON 字符串 → null 不抛错', () => {
+    expect(extractTipTapMarkdown('<p>裸 HTML 历史数据</p>')).toBeNull()
+    expect(extractTipTapMarkdown('not json {{{')).toBeNull()
+  })
+
+  it('null / undefined / 非 JSON 值 → null', () => {
+    expect(extractTipTapMarkdown(null)).toBeNull()
+    expect(extractTipTapMarkdown(undefined)).toBeNull()
+    expect(extractTipTapMarkdown(42)).toBeNull()
+    expect(extractTipTapMarkdown(['x'])).toBeNull()
+  })
+
+  it('JSON 合法但缺 markdown 字段 / markdown 非字符串 / 空串 → null', () => {
+    expect(extractTipTapMarkdown(JSON.stringify({ html: '<p>x</p>' }))).toBeNull()
+    expect(extractTipTapMarkdown(JSON.stringify({ markdown: 123 }))).toBeNull()
+    expect(extractTipTapMarkdown(JSON.stringify({ markdown: '' }))).toBeNull()
+  })
+})
+
+describe('buildSourceContextBlock: story', () => {
+  const storyRow = {
+    identifier: 'ATLAS-S12',
+    name: '用户登录优化',
+    description: TIP_TAP('支持扫码登录'),
+    state: 'in_progress',
+    priority: 'high',
+    project: { name: 'Atlas' },
+    targetDate: new Date('2026-10-15T00:00:00.000Z'),
+  }
+
+  it('注入 identifier/name/markdown 段/状态/优先级/项目名/目标日期', () => {
+    const block = buildSourceContextBlock('story', storyRow)
+    expect(block).toContain('ATLAS-S12')
+    expect(block).toContain('用户登录优化')
+    expect(block).toContain('支持扫码登录')
+    expect(block).toContain('in_progress')
+    expect(block).toContain('high')
+    expect(block).toContain('Atlas')
+    expect(block).toContain('2026-10-15')
+  })
+
+  it('description 为 null：不崩且描述段落省略', () => {
+    const block = buildSourceContextBlock('story', {
+      ...storyRow,
+      description: null,
+    })
+    expect(block).toContain('ATLAS-S12')
+    expect(block).not.toContain('### 描述')
+  })
+
+  it('description 为非法 JSON 字符串：不崩且描述段落省略', () => {
+    const block = buildSourceContextBlock('story', {
+      ...storyRow,
+      description: '<p>裸 HTML</p>',
+    })
+    expect(block).not.toContain('### 描述')
+  })
+})
+
+describe('buildSourceContextBlock: bug', () => {
+  const bugRow = {
+    identifier: 'ATLAS-B7',
+    title: '提交登录表单崩溃',
+    severity: 'high',
+    reproduceSteps: {
+      steps: [
+        { order: 1, action: '打开登录页', expected: '显示表单' },
+        { order: 2, action: '提交空表单' },
+      ],
+      expectedResult: '提示必填',
+      actualResult: '页面白屏',
+    },
+    stackSummary: 'S'.repeat(9000) + 'TAIL-MARKER',
+    url: 'https://app.example.com/login',
+    env: 'prod',
+    story: { name: '用户登录优化' },
+  }
+
+  it('注入 identifier/title/severity/url/env/关联 Story 标题', () => {
+    const block = buildSourceContextBlock('bug', bugRow)
+    expect(block).toContain('ATLAS-B7')
+    expect(block).toContain('提交登录表单崩溃')
+    expect(block).toContain('high')
+    expect(block).toContain('https://app.example.com/login')
+    expect(block).toContain('prod')
+    expect(block).toContain('用户登录优化')
+  })
+
+  it('steps 结构化渲染为 `- [n] action → expected`，无 expected 省略箭头', () => {
+    const block = buildSourceContextBlock('bug', bugRow)
+    expect(block).toContain('- [1] 打开登录页 → 显示表单')
+    expect(block).toContain('- [2] 提交空表单')
+    expect(block).not.toContain('→ 提示必填') // 单步箭头仅用于 expected；整体预期是独立行
+    expect(block).toContain('提示必填')
+  })
+
+  it('stackSummary >8KB：截断到 8192 字符并加 …[截断] 后缀', () => {
+    const block = buildSourceContextBlock('bug', bugRow)
+    expect(block).toContain('…[截断]')
+    expect(block).not.toContain('TAIL-MARKER')
+    // 堆栈正文（不含小节标题）截断后 ≤ 8192 + 后缀长度
+    const stackStart = block.indexOf('S'.repeat(64))
+    expect(stackStart).toBeGreaterThan(0)
+    const tail = block.slice(stackStart)
+    const suffixLen = '…[截断]'.length
+    expect(tail.length).toBeLessThanOrEqual(8192 + suffixLen)
+  })
+
+  it('stackSummary 恰 8192 字符：不截断', () => {
+    const exact = 'S'.repeat(8192)
+    const block = buildSourceContextBlock('bug', { ...bugRow, stackSummary: exact })
+    expect(block).toContain(exact)
+    expect(block).not.toContain('…[截断]')
+  })
+
+  it('reproduceSteps 为空对象 / 非法结构：不崩且复现步骤段落省略', () => {
+    for (const steps of [{}, { steps: [] }, 'garbage', null]) {
+      const block = buildSourceContextBlock('bug', { ...bugRow, reproduceSteps: steps })
+      expect(block).toContain('ATLAS-B7')
+      expect(block).not.toContain('### 复现步骤')
+    }
+  })
+})
+
+describe('buildSourceContextBlock: testcase', () => {
+  const tcRow = {
+    identifier: 'ATLAS-TC3',
+    title: '登录成功用例',
+    precondition: '已注册用户 test@example.com',
+    steps: { steps: [{ order: 1, action: '输入正确密码', expected: '跳转工作台' }] },
+    type: 'functional',
+  }
+
+  it('注入 identifier/title/precondition/steps/type', () => {
+    const block = buildSourceContextBlock('testcase', tcRow)
+    expect(block).toContain('ATLAS-TC3')
+    expect(block).toContain('登录成功用例')
+    expect(block).toContain('已注册用户 test@example.com')
+    expect(block).toContain('- [1] 输入正确密码 → 跳转工作台')
+    expect(block).toContain('functional')
+  })
+
+  it('precondition 为 null 且 steps 为空对象：不崩且两段省略', () => {
+    const block = buildSourceContextBlock('testcase', {
+      ...tcRow,
+      precondition: null,
+      steps: {},
+    })
+    expect(block).toContain('ATLAS-TC3')
+    expect(block).not.toContain('### 前置条件')
+    expect(block).not.toContain('### 测试步骤')
+  })
+})

package/src/server/__tests__/task-executor.test.ts

@@ -0,0 +1,349 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { prisma } from '@allbluecn/database'
+import { runChat } from '@/server/ai-gateway/adapter'
+import { createNotification } from '@/server/notifications/notification-service'
+import { buildSourceContextBlock } from '@/server/ai-task/context-builder'
+import { AI_TASK_ALLOWED_TOOLS, executeAiTaskRun } from '@/server/ai-task/executor'
+import type { ExecuteAiTaskRunOptions } from '@/server/ai-task/executor'
+
+vi.mock('@/server/ai-gateway/adapter', () => ({ runChat: vi.fn() }))
+vi.mock('@/server/notifications/notification-service', () => ({
+  createNotification: vi.fn(),
+}))
+vi.mock('@allbluecn/database', () => ({
+  prisma: {
+    aiTask: { update: vi.fn(), findUnique: vi.fn() },
+    aiTaskRun: { findUnique: vi.fn(), update: vi.fn() },
+    project: { findUnique: vi.fn() },
+    story: { findUnique: vi.fn() },
+    bug: { findUnique: vi.fn() },
+    testCase: { findUnique: vi.fn() },
+  },
+}))
+vi.mock('@/server/ai-task/context-builder', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('@/server/ai-task/context-builder')>()
+  return { ...actual, buildSourceContextBlock: vi.fn(() => '## 需求上下文（mock）') }
+})
+
+const runChatMock = vi.mocked(runChat)
+const createNotificationMock = vi.mocked(createNotification)
+const buildSourceContextBlockMock = vi.mocked(buildSourceContextBlock)
+// prisma delegate 用宽松 mock 类型（同 task-assigned-query.test.ts 惯例），
+// 免去构造完整 Prisma payload：测试只关心 select 收窄后的部分行
+const aiTaskUpdate = prisma.aiTask.update as ReturnType<typeof vi.fn>
+const aiTaskFindUnique = prisma.aiTask.findUnique as ReturnType<typeof vi.fn>
+const aiTaskRunUpdate = prisma.aiTaskRun.update as ReturnType<typeof vi.fn>
+const aiTaskRunFindUnique = prisma.aiTaskRun.findUnique as ReturnType<typeof vi.fn>
+const projectFindUnique = prisma.project.findUnique as ReturnType<typeof vi.fn>
+const storyFindUnique = prisma.story.findUnique as ReturnType<typeof vi.fn>
+const bugFindUnique = prisma.bug.findUnique as ReturnType<typeof vi.fn>
+const testCaseFindUnique = prisma.testCase.findUnique as ReturnType<typeof vi.fn>
+
+const TASK = {
+  id: 'task-1',
+  title: '总结登录需求',
+  instruction: '请总结需求要点并给出建议',
+  sourceType: null,
+  sourceId: null,
+  projectId: null,
+}
+
+function runTask(overrides: Partial<ExecuteAiTaskRunOptions['task']> = {}) {
+  return executeAiTaskRun({ task: { ...TASK, ...overrides }, runId: 'run-1', userId: 'user-1' })
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  runChatMock.mockResolvedValue('结果')
+  createNotificationMock.mockResolvedValue(undefined)
+  aiTaskUpdate.mockResolvedValue({})
+  // 默认落库成功后 task 已是终态 → finally 兜底无操作
+  aiTaskFindUnique.mockResolvedValue({ status: 'completed' })
+  aiTaskRunUpdate.mockResolvedValue({})
+  // 默认落库成功后 run 已是终态 → finally 兜底无操作
+  aiTaskRunFindUnique.mockResolvedValue({ status: 'completed' })
+  vi.spyOn(console, 'error').mockImplementation(() => {})
+  vi.spyOn(console, 'warn').mockImplementation(() => {})
+})
+
+afterEach(() => {
+  vi.unstubAllEnvs()
+  vi.useRealTimers()
+  vi.restoreAllMocks()
+})
+
+describe('executeAiTaskRun', () => {
+  it('成功路径：runChat 结果落库（run completed + task completed）并通知', async () => {
+    await expect(runTask()).resolves.toBeUndefined()
+
+    // runChat 两参数签名：第一参为用户指令 messages，第二参含白名单/userId/parentRunId/systemPrompts
+    expect(runChatMock).toHaveBeenCalledTimes(1)
+    expect(runChatMock).toHaveBeenCalledWith(
+      [{ role: 'user', content: TASK.instruction }],
+      expect.objectContaining({
+        allowedTools: ['knowledge_search', 'user_data_query', 'web_search'],
+        userId: 'user-1',
+        parentRunId: 'run-1',
+        systemPrompts: expect.any(Array),
+      }),
+    )
+
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith({
+      where: { id: 'run-1' },
+      data: expect.objectContaining({
+        status: 'completed',
+        resultSummary: '结果',
+        finishedAt: expect.any(Date),
+        durationMs: expect.any(Number),
+      }),
+    })
+    expect(aiTaskUpdate).toHaveBeenCalledWith({
+      where: { id: 'task-1' },
+      data: { status: 'completed', lastRunId: 'run-1' },
+    })
+
+    expect(createNotificationMock).toHaveBeenCalledTimes(1)
+    expect(createNotificationMock).toHaveBeenCalledWith({
+      userId: 'user-1',
+      category: 'system',
+      type: 'ai_task_finished',
+      title: TASK.title,
+      body: '结果',
+      link: '/tasks/task-1',
+    })
+  })
+
+  it('工具白名单常量恰为三个只读工具', () => {
+    expect([...AI_TASK_ALLOWED_TOOLS]).toEqual([
+      'knowledge_search',
+      'user_data_query',
+      'web_search',
+    ])
+    expect(AI_TASK_ALLOWED_TOOLS).toHaveLength(3)
+  })
+
+  it('抛错路径：run 落 failed + error 截断、task 落 failed、通知仍发', async () => {
+    runChatMock.mockRejectedValue(new Error('第一行错误\n第二行'))
+    await expect(runTask()).resolves.toBeUndefined()
+
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith({
+      where: { id: 'run-1' },
+      data: expect.objectContaining({
+        status: 'failed',
+        error: expect.stringContaining('第一行错误'),
+      }),
+    })
+    expect(aiTaskUpdate).toHaveBeenCalledWith({
+      where: { id: 'task-1' },
+      data: { status: 'failed', lastRunId: 'run-1' },
+    })
+    // 通知 body = 错误首行
+    expect(createNotificationMock).toHaveBeenCalledWith(
+      expect.objectContaining({ body: '第一行错误', link: '/tasks/task-1' }),
+    )
+  })
+
+  it('错误信息超长时截断落库', async () => {
+    runChatMock.mockRejectedValue(new Error('x'.repeat(1000)))
+    await runTask()
+
+    const data = aiTaskRunUpdate.mock.calls[0]?.[0]?.data
+    expect(String(data.error)).toMatch(/…\[截断\]$/)
+    expect(String(data.error).length).toBeLessThanOrEqual(510)
+  })
+
+  it('超时路径：env 注入短超时 + fake timers → run timeout、task failed、通知', async () => {
+    vi.stubEnv('AI_TASK_TIMEOUT_MS', '50')
+    vi.useFakeTimers()
+    runChatMock.mockImplementation(() => new Promise<string>(() => {}))
+
+    const pending = runTask()
+    await vi.advanceTimersByTimeAsync(51)
+    await pending
+
+    expect(runChatMock).toHaveBeenCalledTimes(1)
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith({
+      where: { id: 'run-1' },
+      data: expect.objectContaining({
+        status: 'timeout',
+        error: expect.stringContaining('超时'),
+      }),
+    })
+    expect(aiTaskUpdate).toHaveBeenCalledWith({
+      where: { id: 'task-1' },
+      data: { status: 'failed', lastRunId: 'run-1' },
+    })
+    expect(createNotificationMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('通知失败不阻塞终态落库', async () => {
+    createNotificationMock.mockRejectedValue(new Error('notify down'))
+    await expect(runTask()).resolves.toBeUndefined()
+
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: 'completed' }) }),
+    )
+    expect(aiTaskUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: { status: 'completed', lastRunId: 'run-1' } }),
+    )
+  })
+
+  it('finally 兜底：终态落库失败时 run 非终态被强制落 failed', async () => {
+    aiTaskRunUpdate.mockRejectedValueOnce(new Error('db down')).mockResolvedValue({})
+    aiTaskRunFindUnique.mockResolvedValue({ status: 'running' })
+
+    await expect(runTask()).resolves.toBeUndefined()
+
+    expect(aiTaskRunUpdate).toHaveBeenCalledTimes(2)
+    expect(aiTaskRunUpdate).toHaveBeenLastCalledWith({
+      where: { id: 'run-1' },
+      data: expect.objectContaining({ status: 'failed' }),
+    })
+  })
+
+  it('task 兜底：run 落库成功但 task 落库瞬时失败时，僵尸 running 任务被强制落 failed', async () => {
+    // persistOutcome 顺序：aiTaskRun.update 成功 → aiTask.update 首次失败
+    aiTaskUpdate.mockRejectedValueOnce(new Error('db down')).mockResolvedValue({})
+    // run 已终态（无操作）；task 复查仍是 running → 兜底二次 update 自愈
+    aiTaskRunFindUnique.mockResolvedValue({ status: 'completed' })
+    aiTaskFindUnique.mockResolvedValue({ status: 'running' })
+
+    await expect(runTask()).resolves.toBeUndefined()
+
+    expect(aiTaskUpdate).toHaveBeenCalledTimes(2)
+    expect(aiTaskUpdate).toHaveBeenLastCalledWith({
+      where: { id: 'task-1' },
+      data: { status: 'failed', lastRunId: 'run-1' },
+    })
+    // 终态兜底吞错：外层不向调用方抛出
+    expect(console.error).toHaveBeenCalledWith(
+      '[ai-task] 终态落库/收尾失败:',
+      expect.stringContaining('db down'),
+    )
+  })
+
+  it('task 兜底：backlog（未占位初始态）不误伤，仅 running 才强制落 failed', async () => {
+    aiTaskFindUnique.mockResolvedValue({ status: 'backlog' })
+
+    await expect(runTask()).resolves.toBeUndefined()
+
+    expect(aiTaskUpdate).toHaveBeenCalledTimes(1)
+    expect(aiTaskUpdate).toHaveBeenCalledWith({
+      where: { id: 'task-1' },
+      data: { status: 'completed', lastRunId: 'run-1' },
+    })
+  })
+
+  it('超时判定用专用哨兵：非看门狗抛错的「超时」文案按 failed 分类，不误判 timeout', async () => {
+    runChatMock.mockRejectedValue(new Error('下游服务请求超时'))
+    await runTask()
+
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: 'failed' }) }),
+    )
+    expect(aiTaskUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: 'failed' }) }),
+    )
+  })
+
+  it('通知 body 取结果首行并截 100 字符', async () => {
+    runChatMock.mockResolvedValue('\n' + 'y'.repeat(150) + '\n第二行')
+    await runTask()
+
+    expect(createNotificationMock).toHaveBeenCalledWith(
+      expect.objectContaining({ body: 'y'.repeat(100) }),
+    )
+  })
+
+  it('源型 story：查源表并注入 buildSourceContextBlock 输出到 systemPrompts', async () => {
+    storyFindUnique.mockResolvedValue({
+      identifier: 'ALB-S12',
+      name: '登录页重构',
+      description: null,
+      state: 'in_progress',
+      priority: 'high',
+      targetDate: null,
+      project: { name: '理想之海' },
+    })
+    buildSourceContextBlockMock.mockReturnValue('## 需求上下文（mock）')
+
+    await runTask({ sourceType: 'story', sourceId: 'story-1' })
+
+    expect(storyFindUnique).toHaveBeenCalledWith({
+      where: { id: 'story-1' },
+      select: expect.objectContaining({
+        identifier: true,
+        name: true,
+        description: true,
+        state: true,
+        priority: true,
+        targetDate: true,
+        project: expect.anything(),
+      }),
+    })
+    expect(buildSourceContextBlockMock).toHaveBeenCalledWith(
+      'story',
+      expect.objectContaining({ identifier: 'ALB-S12' }),
+    )
+    const prompts = runChatMock.mock.calls[0]?.[1]?.systemPrompts ?? []
+    expect(prompts).toContain('## 需求上下文（mock）')
+    // 继续执行正常完成
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: 'completed' }) }),
+    )
+  })
+
+  it('源条目已删除：上下文块替换为提示文本并继续执行', async () => {
+    storyFindUnique.mockResolvedValue(null)
+
+    await expect(runTask({ sourceType: 'story', sourceId: 'story-gone' })).resolves.toBeUndefined()
+
+    expect(buildSourceContextBlockMock).not.toHaveBeenCalled()
+    const prompts = runChatMock.mock.calls[0]?.[1]?.systemPrompts ?? []
+    expect(prompts.some((p) => p.includes('源条目已删除'))).toBe(true)
+    expect(aiTaskRunUpdate).toHaveBeenCalledWith(
+      expect.objectContaining({ data: expect.objectContaining({ status: 'completed' }) }),
+    )
+  })
+
+  it('源型分发：bug / testcase 各查对应表', async () => {
+    bugFindUnique.mockResolvedValue({
+      identifier: 'ALB-B3',
+      title: '首页白屏',
+      severity: 'critical',
+      reproduceSteps: null,
+      stackSummary: null,
+      url: null,
+      env: null,
+      story: null,
+    })
+    await runTask({ sourceType: 'bug', sourceId: 'bug-1' })
+    expect(bugFindUnique).toHaveBeenCalledTimes(1)
+    expect(storyFindUnique).not.toHaveBeenCalled()
+    expect(buildSourceContextBlockMock).toHaveBeenCalledWith('bug', expect.anything())
+
+    testCaseFindUnique.mockResolvedValue({
+      identifier: 'ALB-TC7',
+      title: '登录冒烟用例',
+      precondition: null,
+      steps: { steps: [] },
+      type: 'functional',
+    })
+    await runTask({ sourceType: 'testcase', sourceId: 'case-1' })
+    expect(testCaseFindUnique).toHaveBeenCalledTimes(1)
+    expect(buildSourceContextBlockMock).toHaveBeenCalledWith('testcase', expect.anything())
+  })
+
+  it('projectId 存在时查项目名并注入系统提示词', async () => {
+    projectFindUnique.mockResolvedValue({ name: '理想之海' })
+
+    await runTask({ projectId: 'project-1' })
+
+    expect(projectFindUnique).toHaveBeenCalledWith({
+      where: { id: 'project-1' },
+      select: { name: true },
+    })
+    const prompts = runChatMock.mock.calls[0]?.[1]?.systemPrompts ?? []
+    expect(prompts.some((p) => p.includes('理想之海'))).toBe(true)
+  })
+})

package/src/server/__tests__/task-priority-map.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import { mapToUnifiedPriority } from '@/server/ai-task/priority-map'
+
+describe('mapToUnifiedPriority', () => {
+  it('story: urgent→P0, high→P1, medium→P2, low→P3, none/undefined→null', () => {
+    expect(mapToUnifiedPriority('story', 'urgent')).toBe('P0')
+    expect(mapToUnifiedPriority('story', 'critical')).toBe('P0')
+    expect(mapToUnifiedPriority('story', 'high')).toBe('P1')
+    expect(mapToUnifiedPriority('story', 'medium')).toBe('P2')
+    expect(mapToUnifiedPriority('story', 'low')).toBe('P3')
+    expect(mapToUnifiedPriority('story', 'none')).toBeNull()
+    expect(mapToUnifiedPriority('story', undefined)).toBeNull()
+    expect(mapToUnifiedPriority('story', null)).toBeNull()
+  })
+
+  it('bug severity: critical→P0, high→P1, medium→P2, low→P3, 其他→null', () => {
+    expect(mapToUnifiedPriority('bug', 'critical')).toBe('P0')
+    expect(mapToUnifiedPriority('bug', 'high')).toBe('P1')
+    expect(mapToUnifiedPriority('bug', 'medium')).toBe('P2')
+    expect(mapToUnifiedPriority('bug', 'low')).toBe('P3')
+    expect(mapToUnifiedPriority('bug', 'trivial')).toBeNull()
+    expect(mapToUnifiedPriority('bug', undefined)).toBeNull()
+  })
+
+  it('testcase: p0→P0…p3→P3 精确直映', () => {
+    expect(mapToUnifiedPriority('testcase', 'p0')).toBe('P0')
+    expect(mapToUnifiedPriority('testcase', 'p1')).toBe('P1')
+    expect(mapToUnifiedPriority('testcase', 'p2')).toBe('P2')
+    expect(mapToUnifiedPriority('testcase', 'p3')).toBe('P3')
+  })
+
+  it('未知值一律 null 不抛错', () => {
+    expect(() => mapToUnifiedPriority('story', 'asap')).not.toThrow()
+    expect(mapToUnifiedPriority('story', 'asap')).toBeNull()
+    expect(mapToUnifiedPriority('bug', 'urgent')).toBeNull()
+    expect(mapToUnifiedPriority('testcase', 'P0')).toBeNull()
+    expect(mapToUnifiedPriority('testcase', '')).toBeNull()
+    expect(mapToUnifiedPriority('testcase', undefined)).toBeNull()
+    expect(mapToUnifiedPriority('testcase', null)).toBeNull()
+  })
+})