Files
crawler-plugin/frontend-vue/tests/mount/jd-publish-dispatch.mount.test.ts
T
huangzd1997 9b23b4934d feat(jd-publish): 目标品牌建单+校验失败整单判死+改品牌原位重试(桌面协议 v3 服务端半边)
- 建单必填目标品牌(1–120 字符单行),走 /tasks/target-brand 独占路径,旧后端不会静默丢参数

- 激活与明细下发带 jdPublishProtocol,协议 <3 直接 409 要求升级客户端;明细 VO 下发 targetBrandName

- 预检失败回执(SOURCE/BRAND)必须带一条失败明细,整单判 FAILED 并落分类前缀;通用重试/继续对品牌失败任务拒绝

- 新增 /tasks/{taskId}/retry-brand:只允许无成功、无待确认记录的品牌失败任务改品牌后原位重试(世代+1、明细复位、回执直推本机队列)

- 兜底拉取按协议过滤带 targetBrandName 的 JD 上架任务,认领 CAS 带 resumeAttempt 防跨代误领

- 用户端:目标品牌必填输入、协议探测挡旧客户端、品牌失败弹窗与「修改品牌并重试」按钮
2026-11-20 21:48:59 +08:00

309 lines
15 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
import { flushPromises, mount, type VueWrapper } from '@vue/test-utils'
import JdPublishTab from '@/pages/jd/JdPublishTab.vue'
import {
__resetCredentialFatalAlertForTest,
credentialFatalQueueLength,
takeCredentialFatal,
} from '@/shared/stores/credential-fatal-alert'
const api = vi.hoisted(() => ({
create: vi.fn(), activate: vi.fn(), products: vi.fn(), groups: vi.fn(),
history: vi.fn(), progress: vi.fn(), dashboard: vi.fn(), retry: vi.fn(), enqueue: vi.fn(), bridge: vi.fn(),
protocol: vi.fn(), retryBrand: vi.fn(), alert: vi.fn(), prompt: vi.fn(),
}))
vi.mock('@/shared/api/types/modules/jd-collect', () => ({ fetchJdCollectGroups: api.groups }))
vi.mock('@/shared/api/types/modules/jd-publish', () => ({
createJdPublishTask: api.create,
retryJdPublishBrand: api.retryBrand,
activateJdPublishTask: api.activate,
fetchJdPublishDashboard: api.dashboard,
fetchJdPublishHistory: api.history,
fetchJdPublishProducts: api.products,
fetchJdPublishTaskProgressBatch: api.progress,
deleteJdPublishTask: vi.fn(),
interruptJdPublishTask: vi.fn(),
}))
vi.mock('@/shared/utils/categorized-timers.ts', () => ({
createCategorizedTimers: () => ({ setTimeout: () => 1, clearTimer: vi.fn(), clearScope: vi.fn() }),
}))
vi.mock('element-plus', async (importOriginal) => ({
...await importOriginal<typeof import('element-plus')>(),
ElMessage: { success: vi.fn(), error: vi.fn() },
ElMessageBox: { alert: api.alert, prompt: api.prompt },
}))
vi.mock('@/shared/api/task-retry', () => ({ retryClientTask: api.retry }))
vi.mock('@/shared/bridges/pywebview', () => ({ getPywebviewApi: api.bridge }))
const queuePayload = { type: 'jd-product-publish-run', data: { taskId: 88, resumeAttempt: 0, serverOnly: true } }
const loginError = '京麦未登录(登录态失效),请在客户端重新登录京麦后重试'
const brandError = '目标品牌校验失败:商品「蓝牙音箱」的目标品牌「Blue-Sound」在京麦不可选(JD_BRAND_UNAVAILABLE)'
const sourceError = '本店源商品校验失败:当前店铺找不到源商品「蓝牙音箱」,编码 SKU_12345(JD_SOURCE_NOT_FOUND)'
function row(taskStatus: string, resumeAttempt: number, errorMessage?: string) {
return { taskId: 88, taskStatus, resumeAttempt, productTotal: 2, successCount: 0, publishingCount: 0, errorMessage }
}
function batch(item: ReturnType<typeof row>) {
return {
items: [{ task: {
id: item.taskId, status: item.taskStatus, resumeAttempt: item.resumeAttempt, errorMessage: item.errorMessage,
}, items: [item] }],
missingTaskIds: [],
}
}
let wrapper: VueWrapper | undefined
async function mountPage() {
wrapper = mount(JdPublishTab, {
global: {
stubs: {
NotificationBell: true, RouterLink: true, ElOption: true,
ElSelect: { props: ['modelValue'], emits: ['update:modelValue', 'change'], template: '<div><slot /></div>' },
ElPagination: { emits: ['current-change'], template: '<div />' }, ElInputNumber: true,
ElDrawer: { props: ['modelValue'], template: '<div v-if="modelValue"><slot /></div>' },
},
directives: { loading: () => undefined },
},
})
await flushPromises()
return wrapper
}
async function startPublish(page: VueWrapper, brand = ' 示例品牌 ') {
await page.get('.target-brand-input').setValue(brand)
await page.get<HTMLInputElement>('.product-check').setValue(true)
await page.get('.collect-btn').trigger('click')
await flushPromises()
}
beforeEach(() => {
for (const mock of Object.values(api)) mock.mockReset()
api.groups.mockResolvedValue([{ id: 12, name: '共享类目' }])
api.products.mockResolvedValue({ items: [{ id: 23, title: '示例商品' }], total: 1 })
api.create.mockResolvedValue({ taskId: 88, queuePayload })
api.activate.mockResolvedValue(null)
api.dashboard.mockResolvedValue({ pendingTaskCount: 0, processedTaskCount: 0, successTaskCount: 0, failedTaskCount: 0 })
api.history.mockResolvedValue({ items: [] })
api.progress.mockResolvedValue(batch(row('PENDING', 0)))
api.bridge.mockReturnValue({ jd_publish_protocol: api.protocol, enqueue_json: api.enqueue })
api.protocol.mockResolvedValue(3)
api.alert.mockResolvedValue(undefined)
api.enqueue.mockResolvedValue({ success: true })
api.retry.mockResolvedValue(null)
vi.spyOn(console, 'error').mockImplementation(() => undefined)
})
afterEach(() => {
wrapper?.unmount()
wrapper = undefined
__resetCredentialFatalAlertForTest()
localStorage.clear()
vi.restoreAllMocks()
})
it('建单只原样投递服务端载荷,网页不激活任务', async () => {
const page = await mountPage()
await startPublish(page)
expect(page.get('#jd-publish-brand-hint').text()).toContain('本次选中的商品统一使用此品牌,不会修改京东数据库')
expect(api.protocol).toHaveBeenCalled()
expect(api.create).toHaveBeenCalledExactlyOnceWith(12, [23], { mode: 'none' }, '示例品牌')
expect(api.enqueue).toHaveBeenCalledOnce()
expect(api.enqueue.mock.calls[0][0]).toBe(queuePayload)
expect(api.activate).not.toHaveBeenCalled()
})
it.each(['没有桥', '旧桥', '旧协议', '字符串协议', '未知协议', '协议异常'])('%s不允许建品牌单', async (failure) => {
if (failure === '没有桥') api.bridge.mockReturnValue(undefined)
if (failure === '旧桥') api.bridge.mockReturnValue({ enqueue_json: api.enqueue })
if (failure === '旧协议') api.protocol.mockResolvedValue(2)
if (failure === '字符串协议') api.protocol.mockResolvedValue('3')
if (failure === '未知协议') api.protocol.mockResolvedValue(4)
if (failure === '协议异常') api.protocol.mockRejectedValue(new Error('bridge unavailable'))
const page = await mountPage()
await startPublish(page)
expect(api.create).not.toHaveBeenCalled()
expect(api.enqueue).not.toHaveBeenCalled()
expect(page.text()).toContain('升级')
})
it.each([' ', '品'.repeat(121)])('目标品牌名空白或超长时不建单', async (brand) => {
const page = await mountPage()
await startPublish(page, brand)
expect(page.get<HTMLButtonElement>('.collect-btn').element.disabled).toBe(true)
expect(api.create).not.toHaveBeenCalled()
})
it.each(['没有入队方法', '队列拒绝', '桥异常', '没有服务端载荷'])('%s时保留待认领,不拼载荷也不误报建单失败', async (failure) => {
if (failure === '没有入队方法') api.bridge.mockReturnValue({ jd_publish_protocol: api.protocol })
if (failure === '队列拒绝') api.enqueue.mockResolvedValue({ success: false, error: 'queue rejected' })
if (failure === '桥异常') api.enqueue.mockRejectedValue(new Error('bridge unavailable'))
if (failure === '没有服务端载荷') api.create.mockResolvedValue({ taskId: 88 })
const page = await mountPage()
await startPublish(page)
expect(api.activate).not.toHaveBeenCalled()
if (failure === '没有入队方法' || failure === '没有服务端载荷') expect(api.enqueue).not.toHaveBeenCalled()
expect(page.get('.feedback').text()).toContain('任务已创建')
expect(page.get('.feedback').text()).toContain('客户端')
expect(page.get('.status').text()).toContain('等待本机客户端领取')
expect(page.text()).not.toContain('queue rejected')
})
it('切换分类后迟到的旧商品列表不能再参与勾选', async () => {
api.groups.mockResolvedValue([{ id: 12, name: '原分类' }, { id: 13, name: '新分类' }])
let resolveOld!: (data: { items: { id: number, title: string }[], total: number }) => void
api.products.mockImplementationOnce(() => new Promise((resolve) => { resolveOld = resolve }))
api.products.mockResolvedValueOnce({ items: [{ id: 24, title: '新分类商品' }], total: 1 })
const page = await mountPage()
const select = page.getComponent('.shop-cat-select')
select.vm.$emit('update:modelValue', 13)
select.vm.$emit('change', 13)
await flushPromises()
resolveOld({ items: [{ id: 23, title: '旧分类商品' }], total: 1 })
await flushPromises()
expect(page.get('.product-title').text()).toBe('新分类商品')
await startPublish(page)
expect(api.create).toHaveBeenCalledExactlyOnceWith(13, [24], { mode: 'none' }, '示例品牌')
})
it('全选和取消只影响本页,其他页勾选保留', async () => {
api.products.mockResolvedValueOnce({ items: [{ id: 23, title: '第一页商品' }], total: 13 })
api.products.mockResolvedValueOnce({ items: [{ id: 24, title: '第二页商品' }], total: 13 })
const page = await mountPage()
await page.get('.product-select-page').setValue(true)
page.getComponent('.product-pager').vm.$emit('current-change', 2)
await flushPromises()
await page.get('.product-select-page').setValue(true)
expect(page.get('.collect-btn').text()).toContain('2 个商品')
await page.get('.product-select-page').setValue(false)
await page.get('.target-brand-input').setValue('示例品牌')
await page.get('.collect-btn').trigger('click')
await flushPromises()
expect(api.create).toHaveBeenCalledExactlyOnceWith(12, [23], { mode: 'none' }, '示例品牌')
})
it('原位重试只由兜底认领,迟到的旧代终态不能停掉轮询或弹窗', async () => {
api.history.mockResolvedValue({ items: [row('FAILED', 3, loginError)] })
api.progress.mockResolvedValue(batch(row('FAILED', 3, loginError)))
const page = await mountPage()
await page.get('.history-btn').trigger('click')
await page.get('.btn-retry').trigger('click')
await flushPromises()
expect(api.retry).toHaveBeenCalledExactlyOnceWith(88)
expect(api.activate).not.toHaveBeenCalled()
expect(api.enqueue).not.toHaveBeenCalled()
expect(credentialFatalQueueLength()).toBe(0)
expect(page.find('.btn-retry').exists()).toBe(false)
expect(localStorage.getItem('jd-publish:tasks:0')).toBe('[88]')
api.history.mockResolvedValue({ items: [row('RUNNING', 4)] })
api.progress.mockResolvedValue(batch(row('RUNNING', 4)))
await page.get('.panel-refresh').trigger('click')
await flushPromises()
await flushPromises()
expect(page.get('.status').text()).toBe('正在发布到京麦…')
expect(page.text()).not.toContain(loginError)
// 新代已进入 RUNNING,此时再晚到一条旧代终态也不能结算。
api.progress.mockResolvedValue(batch(row('FAILED', 3, loginError)))
await page.get('.panel-refresh').trigger('click')
await flushPromises()
expect(credentialFatalQueueLength()).toBe(0)
expect(localStorage.getItem('jd-publish:tasks:0')).toBe('[88]')
api.progress.mockResolvedValue(batch(row('FAILED', 4, loginError)))
await page.get('.panel-refresh').trigger('click')
await flushPromises()
await flushPromises()
expect(credentialFatalQueueLength()).toBe(1)
expect(takeCredentialFatal()?.notice.body).toContain('请在客户端重新登录京麦')
expect(localStorage.getItem('jd-publish:tasks:0')).toBeNull()
})
it('轮询只凭任务头识别失败,历史和重复轮询不重弹,新代可再弹', async () => {
localStorage.setItem('jd-publish:tasks:0', '[88]')
api.history.mockResolvedValue({ items: [row('RUNNING', 3)] })
const progress = batch(row('FAILED', 3, brandError))
progress.items[0].items[0].errorMessage = undefined
api.progress.mockResolvedValue(progress)
const page = await mountPage()
expect(api.alert).toHaveBeenCalledTimes(1)
expect(api.alert.mock.calls[0].join(' ')).toContain('商品「蓝牙音箱」的目标品牌「Blue-Sound」在京麦不可选')
expect(api.alert.mock.calls[0].join(' ')).not.toContain('JD_BRAND_UNAVAILABLE')
await page.get('.history-btn').trigger('click')
expect(page.get('.btn-retry').text()).toBe('修改品牌并重试')
expect(page.text()).toContain('商品「蓝牙音箱」的目标品牌「Blue-Sound」在京麦不可选')
expect(page.text()).not.toContain('JD_BRAND_UNAVAILABLE')
api.history.mockResolvedValue({ items: [row('FAILED', 3, brandError)] })
await page.get('.panel-refresh').trigger('click')
await flushPromises()
expect(api.alert).toHaveBeenCalledTimes(1)
api.history.mockResolvedValue({ items: [row('FAILED', 4, brandError)] })
await page.get('.panel-refresh').trigger('click')
await flushPromises()
expect(api.alert).toHaveBeenCalledTimes(2)
})
it('修改品牌走专用原位重试,原样投递新载荷并拒绝旧代进度', async () => {
api.history.mockResolvedValue({ items: [row('FAILED', 3, brandError)] })
api.progress.mockResolvedValue(batch(row('FAILED', 3, brandError)))
api.prompt.mockResolvedValue({ value: ' 新品牌 ' })
const retryPayload = { ...queuePayload, data: { taskId: 88, resumeAttempt: 4, serverOnly: true } }
api.retryBrand.mockResolvedValue({ taskId: 88, queuePayload: retryPayload })
const page = await mountPage()
await page.get('.history-btn').trigger('click')
await page.get('.btn-retry').trigger('click')
await flushPromises()
expect(api.prompt).toHaveBeenCalledOnce()
expect(api.retryBrand).toHaveBeenCalledExactlyOnceWith(88, '新品牌', 3)
expect(api.enqueue.mock.calls[0][0]).toBe(retryPayload)
expect(api.retry).not.toHaveBeenCalled()
expect(api.create).not.toHaveBeenCalled()
expect(api.alert).toHaveBeenCalledTimes(1)
expect(localStorage.getItem('jd-publish:tasks:0')).toBe('[88]')
})
it('旧桥不允许修改品牌并重试', async () => {
api.bridge.mockReturnValue({ enqueue_json: api.enqueue })
api.history.mockResolvedValue({ items: [row('FAILED', 0, brandError)] })
const page = await mountPage()
await page.get('.history-btn').trigger('click')
await page.get('.btn-retry').trigger('click')
await flushPromises()
expect(api.prompt).not.toHaveBeenCalled()
expect(api.retryBrand).not.toHaveBeenCalled()
expect(api.retry).not.toHaveBeenCalled()
})
it.each([{ successCount: 1 }, { publishingCount: 1 }])('已有成功或待确认时禁止品牌重试:%o', async (counts) => {
api.history.mockResolvedValue({ items: [{ ...row('FAILED', 3, brandError), ...counts }] })
const page = await mountPage()
await page.get('.history-btn').trigger('click')
expect(page.find('.btn-retry').exists()).toBe(false)
expect(page.text()).toContain('核对京麦')
expect(page.text()).toContain('未发布商品')
expect(page.text()).not.toContain('JD_BRAND_UNAVAILABLE')
})
it('源商品失败提示换店或重选,并保留普通原位重试', async () => {
api.history.mockResolvedValue({ items: [row('FAILED', 0, sourceError)] })
const page = await mountPage()
await page.get('.history-btn').trigger('click')
expect(page.text()).toContain('正确店铺')
expect(page.text()).toContain('重新选择')
expect(page.text()).toContain('当前店铺找不到源商品「蓝牙音箱」,编码 SKU_12345')
expect(page.text()).not.toContain('JD_SOURCE_NOT_FOUND')
expect(api.alert).toHaveBeenCalledOnce()
expect(api.alert.mock.calls[0].join(' ')).toContain('当前店铺找不到源商品「蓝牙音箱」,编码 SKU_12345')
expect(api.alert.mock.calls[0].join(' ')).not.toContain('JD_SOURCE_NOT_FOUND')
expect(page.get('.btn-retry').text()).toBe('重试')
await page.get('.btn-retry').trigger('click')
await flushPromises()
expect(api.retry).toHaveBeenCalledExactlyOnceWith(88)
expect(api.retryBrand).not.toHaveBeenCalled()
})