Files
crawler-plugin/frontend-vue/tests/mount/jd-publish-dispatch.mount.test.ts
T
huangzd1997 6a52e24eb9 feat(web): 京东工具台三页头部加密钥设置入口(2026-11-22 用户口径「这边也要加密钥设置」,京东上架 AI 补值要读登录用户 LLM 密钥)
- BrandApiSecretSettingsButton 加可选 showProxy(默认 true,亚马逊侧现有调用零变化);透传面板既有 showProxy(708/771 行已按它条件保存/余额);副标题按 showProxy 派生(隐藏代理时不再提「代理设置保存在当前客户端」)
- JdConsolePage/JdCollectTab/JdPublishTab 头部 .top-right(铃铛与用户名之间)各插 <BrandApiSecretSettingsButton variant="topbar" :show-proxy="false"/>——京东特性无代理消费方,隐藏代理区防「没配代理影响京东采集吗」误判(铁律 27 同款)
- 弹窗/保存/检测/余额走既有 /newApi/api/user-secrets 链,零新端点零新权限 key
- 判据:jd-secret-entry.test.ts(三页头部精确匹配+按钮四钉)+jd-secret-entry.mount.test.ts(top-right 触发钮/showProxy 透传/副标题三用例);四支既有 JD mount 补 ApiSecretSettingsPanel stub 防真发 fetch(31 绿+mount 59 绿零噪声+vue-tsc rc=0)

随下一 app-web 窗上线
2026-11-22 21:51:45 +08:00

344 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,
// 2026-11-22 JD 页头部挂了密钥设置按钮:面板替身化,别在挂载用例里真发 /user-secrets fetch
ApiSecretSettingsPanel: 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('非在售商品')
})