Files
crawler-plugin/frontend-vue/tests/mount/jd-publish-dispatch.mount.test.ts
T

342 lines
17 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()
})
it('普通重试把响应带回的直推载荷推回本机队列(复位是 PENDING,兜底拉取默认关闭)', async () => {
api.history.mockResolvedValue({ items: [row('FAILED', 3, loginError)] })
api.progress.mockResolvedValue(batch(row('FAILED', 3, loginError)))
const retryPayload = { ...queuePayload, data: { taskId: 88, resumeAttempt: 4, serverOnly: true } }
api.retry.mockResolvedValue({ queuePayload: retryPayload })
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.enqueue).toHaveBeenCalledExactlyOnceWith(retryPayload)
expect(api.activate).not.toHaveBeenCalled()
expect(api.retryBrand).not.toHaveBeenCalled()
})
it('服务端不带直推载荷时重试维持兜底口径,不推空载荷', async () => {
api.history.mockResolvedValue({ items: [row('FAILED', 0, sourceError)] })
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.enqueue).not.toHaveBeenCalled()
})
it('源商品身份缺失形状已被客户端放行,提示维持换店或重选口径', async () => {
// 2026-11-21 复测:京麦不再回显克隆源身份(人工入口同形状),客户端对该形状放行;
// 前端不再有「改用非在售商品」的分档——分档文案断言的是已推翻的口径,回归即红。
const page = await mountPage()
await page.get('.history-btn').trigger('click')
expect(page.text()).not.toContain('非在售商品')
})