fix(phase-5): v1.5 CR 消项 JD-PUB-01~07 服务端半边(蓝图 docs/ITERATION_PLAN.md Phase 5)——①JD-PUB-01 发布端点收有效用户会话+任务归属闸(AdminAuthSupport 身份源收口,outlet 分母随行,RequestSuppliedIdentityOutletTest +1);②JD-PUB-02 建单/原位重试补事务边界防半截状态;③JD-PUB-03 回传校验执行代次与许可批次(V213__jd_publish_item_permit 两列 nullable 扩展,Expand-and-Contract;旧代不写新代、重复回执幂等、未处理明细不产 SUCCESS);④JD-PUB-04 入队不再等于认领(激活与桌面推送顺序,兜底保留);⑤JD-PUB-05 未知提交不自动重发;⑥JD-PUB-06 旧代终态不触发新代收尾或弹窗(credential-fatal 旧代隔离+京麦登录失效识别);⑦JD-PUB-07 选品切分类丢弃迟到响应、全选只影响本页;新增 mount 测试 jd-publish-dispatch。判据:后端点名 11 类 88 例+整量 mvn -o test 5,716 例 0 失败 0 错误 19 skip BUILD SUCCESS(00:07,7:12min);用户端 vue-tsc rc0+node --test 31+vitest mount 8 全绿;full 闸门 overall=pass 四面绿(2026-11-18 23:59:16);真机 AC-1~AC-9 联验与发版未做,Phase 5 保持未勾

This commit is contained in:
2026-11-19 00:09:46 +08:00
parent 4de78adfc7
commit 77bfd4cf1b
40 changed files with 770 additions and 546 deletions
+115 -77
View File
@@ -8,7 +8,6 @@ import {
type JdCollectGroupVo,
} from '@/shared/api/types/modules/jd-collect'
import {
activateJdPublishTask,
createJdPublishTask,
deleteJdPublishTask,
fetchJdPublishDashboard,
@@ -35,12 +34,9 @@ import NotificationBell from '@/shared/components/NotificationBell.vue'
* 当前登录用户的行),页内翻页、勾选跨页累计;
* 2. 改价规则三档(none/percent/fixed,蓝图 §3 死契约),与勾选集一起进建单体;服务端按
* 同一规则折算 SKU 价(铁律 27a 改价同源);
* 3. 建单成功把服务端下发的 queuePayload(type=jd-product-publish-run,铁律 32 第三件)原样
* 推进本机客户端队列;激活(PENDING→RUNNING)必须在推队列之前(2026-11-14 采集链真机
* 实录同因);推送失败不回滚建单(兜底拉取认领);
* 3. 网页原样转交建单响应的 queuePayload;认领只由客户端与后端完成,投递失败仍可由客户端拉取;
* 4. 进度只读服务端:行级四档计数来自发布明细表聚合,total 缺失时只报已发布行数,不编造百分比;
* 5. 失败/中断「重试/继续」走通用原位复位(铁律 26,不克隆),推送载荷从历史行的建单载荷
* (分类 id+改价规则)同源重建——与建单响应 queuePayload 同键同形状;
* 5. 失败/中断「重试/继续」走通用原位复位(铁律 26,不克隆),新一轮由客户端拉取认领;
* 6. 京麦未登录等凭据致命失败(铁律 31):服务端整单判死后 useLiveTaskBoard 经
* reportCredentialFatal 弹一次窗(credential-fatal 同形接入,AC-5 用户端半边;弹窗组件
* 挂 App.vue,本页无需重复挂)。
@@ -85,8 +81,22 @@ const productTotal = ref(0)
const productPage = ref(1)
const productsLoading = ref(false)
const selectedProducts = ref(new Map<number, JdPublishProductVo>())
let productRequest = 0
const selectedProductIds = computed(() => Array.from(selectedProducts.value.keys()))
const wholePageSelected = computed(() => products.value.length > 0
&& products.value.every((row) => selectedProducts.value.has(row.id)))
const partOfPageSelected = computed(() => !wholePageSelected.value
&& products.value.some((row) => selectedProducts.value.has(row.id)))
function togglePage(checked: boolean) {
const next = new Map(selectedProducts.value)
for (const row of products.value) {
if (checked) next.set(row.id, row)
else next.delete(row.id)
}
selectedProducts.value = next
}
function toggleProduct(row: JdPublishProductVo, checked: boolean) {
const next = new Map(selectedProducts.value)
@@ -100,18 +110,35 @@ function clearSelection() {
}
async function loadProducts() {
const request = ++productRequest
products.value = []
if (selectedGroupId.value == null) {
productTotal.value = 0
productsLoading.value = false
return
}
productsLoading.value = true
try {
const vo = await fetchJdPublishProducts(selectedGroupId.value, productPage.value, PRODUCT_PAGE_SIZE)
if (request !== productRequest) return
products.value = vo.items ?? []
productTotal.value = vo.total ?? 0
} catch (err) {
errorMessage.value = err instanceof Error ? err.message : '商品列表拉取失败,请稍后重试'
if (request === productRequest) {
errorMessage.value = err instanceof Error ? err.message : '商品列表拉取失败,请稍后重试'
}
} finally {
productsLoading.value = false
if (request === productRequest) productsLoading.value = false
}
}
function changeGroup() {
productPage.value = 1
productTotal.value = 0
clearSelection()
void loadProducts()
}
function changePage(page: number) {
productPage.value = page
void loadProducts()
@@ -134,12 +161,54 @@ const submitDisabled = computed(() =>
|| !selectedProducts.value.size
|| priceValueMissing.value)
// 重试回执不带代数:旧代 + 1 只用作读侧下限,不生成任务或队列数据。
const retryAttemptFloor = new Map<number, number>()
const awaitingRetryProgress = new Set<number>()
const retryingTaskIds = ref(new Set<number>())
function acceptsAttempt(taskId: number | undefined, attempt: number | undefined) {
const floor = taskId == null ? undefined : retryAttemptFloor.get(taskId)
return floor == null || (attempt != null && attempt >= floor)
}
async function fetchCurrentHistory(): ReturnType<typeof fetchJdPublishHistory> {
const history = await fetchJdPublishHistory()
return {
...history,
items: history.items.flatMap((item): JdPublishHistoryItemVo[] => {
if (acceptsAttempt(item.taskId, item.resumeAttempt)) return [item]
const current = board.historyItems.value.find((row) => row.taskId === item.taskId)
return current && acceptsAttempt(current.taskId, current.resumeAttempt) ? [current] : []
}),
}
}
async function fetchCurrentProgress(taskIds: number[], { force }: { force: boolean }) {
const floorsAtRequest = new Map(taskIds.map((id) => [id, retryAttemptFloor.get(id)]))
const unchanged = (id: number) => !retryingTaskIds.value.has(id)
&& retryAttemptFloor.get(id) === floorsAtRequest.get(id)
const batch = await fetchJdPublishTaskProgressBatch(taskIds, {
force: force || taskIds.some((id) => awaitingRetryProgress.has(id)),
})
return {
...batch,
items: batch.items.filter(({ task, items }) => {
if (task?.id == null || !unchanged(task.id) || !acceptsAttempt(task.id, task.resumeAttempt)) return false
const row = items?.[0]
if (row && !acceptsAttempt(task.id, row.resumeAttempt)) return false
awaitingRetryProgress.delete(task.id)
return true
}),
missingTaskIds: batch.missingTaskIds.filter(unchanged),
}
}
// ---- 实时任务面板(照 JdCollectTab 的 useLiveTaskBoard 形状;京东发布无结果文件,无下载层)----
const board = useLiveTaskBoard<JdPublishHistoryItemVo>({
scope: 'jd-publish',
pollingStorageKey: () => `jd-publish:tasks:${uidForStorage()}`,
fetchHistory: fetchJdPublishHistory,
fetchProgressBatch: fetchJdPublishTaskProgressBatch,
fetchHistory: fetchCurrentHistory,
fetchProgressBatch: fetchCurrentProgress,
fetchDashboard: fetchJdPublishDashboard,
normalizeTaskStatus,
// 京东发布没有结果文件:状态到终态即结束,没有「等文件」那一层
@@ -291,25 +360,23 @@ async function interruptTaskRecord(item: JdPublishHistoryItemVo | null | undefin
async function retryTaskRecord(item: JdPublishHistoryItemVo | null | undefined) {
const taskId = item?.taskId
if (!taskId) return
if (!taskId || retryingTaskIds.value.has(taskId)) return
const isResume = normalizeTaskStatus(item) === 'CANCELLED'
try {
await retryClientTask(taskId)
ElMessage.success(isResume
? '已继续:在这条任务上接着跑(已成功的商品不会重复发布)'
: '已提交重试:在这条任务上继续跑(不新建任务)')
// 复位是 PENDING:与建单同一条激活+推队列链路,客户端才会立刻领到这一单。
const activateError = await activateTask(taskId)
if (!activateError) {
const priceRule = item?.priceRule && item.priceRule.mode ? item.priceRule : { mode: 'none' }
// 推送载荷从历史行的建单载荷同源重建(与建单响应 queuePayload 同键:type/taskId/priceRule)。
await pushToClientQueue({ type: 'jd-product-publish-run', data: { taskId, priceRule } })
}
board.addPollingTask(taskId)
await refreshBoard()
} catch (error) {
retryingTaskIds.value.add(taskId)
const retried = await retryClientTask(taskId).then(() => true, (error: unknown) => {
ElMessage.error(error instanceof Error ? error.message : '重试失败')
}
return false
})
retryingTaskIds.value.delete(taskId)
if (!retried) return
retryAttemptFloor.set(taskId, (item.resumeAttempt ?? 0) + 1)
awaitingRetryProgress.add(taskId)
board.removePollingTask(taskId)
board.historyItems.value = board.historyItems.value.filter((row) => row.taskId !== taskId)
board.addPollingTask(taskId)
ElMessage.success(isResume ? '已提交继续,等待本机客户端领取' : '已提交原任务重试,等待本机客户端领取')
await refreshBoard().catch((error) => console.error('[jd-publish] 重试后刷新任务失败', error))
}
/** 手动刷新:强拉历史 + 统计 + 当前轮询任务进度 */
@@ -321,38 +388,21 @@ async function refreshBoard() {
])
}
/** 激活任务(PENDING→RUNNING),返回 null 表示可推队列,返回 string 表示失败原因。
* 漏掉这一步,客户端第一个回传会被「任务不在运行中(PENDING)」拒收(采集链真机实录同因)。 */
async function activateTask(id: number): Promise<string | null> {
try {
await activateJdPublishTask(id)
return null
} catch (err) {
const text = err instanceof Error ? err.message : ''
// 客户端兜底拉取已原子认领(PENDING→RUNNING)时后端回这句:等同激活成功,不当失败展示。
if (text.includes('已在执行中')) {
return null
}
console.error('[jd-publish] 激活任务失败', err)
return '任务激活失败,本机客户端领不到这一单,请稍后重试'
}
}
const WAIT_FOR_CLIENT = '任务已创建,等待本机客户端领取。请保持客户端在线。'
/** 推送本机队列:建单路径传服务端下发的 queuePayload(页面不拼载荷),重试路径按同键形状重建后传入。 */
async function pushToClientQueue(payload: Record<string, unknown>): Promise<string | null> {
async function pushToClientQueue(payload: Record<string, unknown> | undefined): Promise<string | null> {
if (!payload) return WAIT_FOR_CLIENT
const api = getPywebviewApi()
if (!api?.enqueue_json) {
return '当前环境未启用任务队列能力(浏览器预览环境不会启动),请在本机客户端中打开本页'
return '任务已创建,等待本机客户端领取。请打开本机客户端并登录同一账号。'
}
const pushResult = await api.enqueue_json(payload)
if (pushResult?.success) {
const result = await api.enqueue_json(payload).catch((error) => {
console.error('[jd-publish] 推送本机队列失败', error)
return null
}
// 桥返回的 error 原文(系统/英文)不透传进界面:console 留链,界面固定中文动作句
if (pushResult?.error) {
console.error('[jd-publish] enqueue_json 被拒', pushResult.error)
}
return '推送本机队列失败,任务将由客户端兜底拉取认领'
})
if (result?.success) return null
if (result?.error) console.error('[jd-publish] enqueue_json 被拒', result.error)
return '任务已创建,但未能推送到本机队列。请保持客户端在线,客户端会自动领取。'
}
const isRunning = computed(() => Boolean(board.dashboard.value.pendingTaskCount) || submitting.value)
@@ -378,29 +428,11 @@ async function startPublish() {
const productIds = selectedProductIds.value
const vo = await createJdPublishTask(categoryId, productIds, priceRule)
board.addPollingTask(vo.taskId)
let pushNote = ''
const activateError = await activateTask(vo.taskId)
if (activateError) {
// 没激活成功就不推队列:推了也是白跑一轮。任务留在 PENDING,
// 由服务端兜底拉取认领后照样会跑,所以这里只提示、不回滚建单。
pushNote = activateError
} else {
try {
// 建单响应自带 queuePayload(服务端组装,铁律 32 第三件),页面原样投递。
const pushError = await pushToClientQueue(vo.queuePayload
?? { type: 'jd-product-publish-run', data: { taskId: vo.taskId, priceRule } })
if (pushError) pushNote = pushError
} catch (pushErr) {
pushNote = '推送本机队列失败,任务将由服务端兜底派发给本机客户端执行'
console.error('[jd-publish] 推送本机队列失败', pushErr)
}
}
if (pushNote) {
errorMessage.value = pushNote
} else {
successMessage.value = `任务已创建(${productIds.length} 个商品)并推送给本机客户端,进度显示在右侧任务区`
}
const pushNote = await pushToClientQueue(vo.queuePayload)
successMessage.value = pushNote
?? `任务已创建(${productIds.length} 个商品)并送入本机队列,等待客户端领取。`
await Promise.all([board.loadDashboard(), board.loadHistory({ force: true })])
.catch((error) => console.error('[jd-publish] 建单后刷新任务失败', error))
} catch (err) {
errorMessage.value = err instanceof Error ? err.message : '建单失败,请稍后重试'
} finally {
@@ -458,7 +490,7 @@ onUnmounted(() => {
<div class="category-block">
<span class="category-label">自定义分类</span>
<el-select v-model="selectedGroupId" placeholder="选择分类" class="shop-cat-select"
:loading="groupsLoading" @change="() => { productPage = 1; clearSelection(); void loadProducts() }">
:loading="groupsLoading" @change="changeGroup">
<el-option v-for="group in groupOptions" :key="group.id"
:label="`${group.name}(${group.productCount ?? 0} 个商品)`" :value="group.id" />
</el-select>
@@ -468,6 +500,12 @@ onUnmounted(() => {
<div class="product-block" v-loading="productsLoading">
<div class="product-head">
<span class="category-label">选择商品(已选 {{ selectedProducts.size }} 个,跨页累计)</span>
<label v-if="products.length" class="category-hint">
<input type="checkbox" class="product-select-page" :checked="wholePageSelected"
:indeterminate.prop="partOfPageSelected"
@change="togglePage(($event.target as HTMLInputElement).checked)" />
全选本页
</label>
<button v-if="selectedProducts.size" class="shop-cat-clear" type="button"
@click="clearSelection">清空勾选</button>
</div>
+1 -3
View File
@@ -226,12 +226,10 @@ export const API_ENDPOINTS = {
/** 删除任务(连带清理京东数据库该任务的商品/图片/SKU 行与断点游标) */
deleteTask: '/api/jd-collect/tasks/{taskId}',
},
/** 京东商品上架(v1.5 Phase 4):用户端建单/激活/选品/面板;派发载荷 type=jd-product-publish-run 由服务端下发 */
/** 京东商品上架:用户端建单/选品/面板;派发载荷由服务端下发,认领只由客户端和后端完成。 */
jdPublish: {
/** 建单(请求体 categoryId+productIds+priceRule,响应带 queuePayload 页面直推) */
create: '/api/jd-publish/tasks',
/** 激活(PENDING→RUNNING):推客户端队列之前必须调用(2026-11-14 采集链真机实录同因) */
activate: '/api/jd-publish/tasks/{taskId}/activate',
/** 用户端选品分页(AC-9 owner 过滤:只回归属当前用户的京东数据库商品行) */
products: '/api/jd-publish/products',
/** 任务面板总览(运行中/成功/失败计数统计卡) */
@@ -20,7 +20,7 @@ export interface JdPublishTaskVo {
taskId: number;
taskNo?: string;
collectChannel?: string;
/** {type:'jd-product-publish-run', data:{taskId, priceRule}}(铁律 32 第三件) */
/** 服务端完整载荷,包含任务代数;网页只转交,不读取或重建 data。 */
queuePayload?: Record<string, unknown>;
}
@@ -52,13 +52,6 @@ export function createJdPublishTask(
))
}
/** 激活任务(PENDING→RUNNING):推客户端队列之前必须调用(漏掉=分片全被拒,采集链真机实录同因)。 */
export function activateJdPublishTask(taskId: number) {
const path = buildJavaUrl(API_ENDPOINTS.jdPublish.activate.replace('{taskId}', String(taskId)))
const query = `?user_id=${encodeURIComponent(String(getCurrentUserId()))}`
return unwrapJavaResponse(post<JavaApiResponse<null>, Record<string, unknown>>(path + query, {}))
}
// ---------------------------------------------------------------------------
// 选品分页(AC-9 owner 过滤):服务端只回归属当前用户的京东数据库商品行。
// 形状照后管京东数据库列表行裁剪(选品面板只需要主字段,attr/detail 不下发)。
@@ -126,9 +119,11 @@ export interface JdPublishHistoryItemVo {
taskStatus?: string;
success?: boolean;
errorMessage?: string;
/** 建单所选自定义分类 id;重试重建推送载荷时同源带回 */
/** 由后端递增的原位重试代数;首轮为 0。 */
resumeAttempt?: number;
/** 建单所选自定义分类 id。 */
categoryId?: number;
/** 建单统一改价规则(原样带回;重试重建推送载荷与建单响应 queuePayload 同键) */
/** 建单统一改价规则。 */
priceRule?: { mode?: string; value?: number };
/** 商品明细总行数 */
productTotal?: number;
@@ -151,6 +146,7 @@ export interface JdPublishTaskDetailVo {
id?: number;
taskNo?: string;
status?: string;
resumeAttempt?: number;
errorMessage?: string;
updatedAt?: string;
};
@@ -10,7 +10,7 @@
* (用户只看到一行消失)或「界面弹了但其实还在跑」(拿抖动陪葬)的错位。
*/
export type CredentialFatalKind = 'llm_balance' | 'proxy' | 'key_invalid'
export type CredentialFatalKind = 'llm_balance' | 'proxy' | 'key_invalid' | 'jd_login'
export interface CredentialFatalNotice {
kind: CredentialFatalKind
@@ -120,6 +120,12 @@ export function credentialFatalNotice(message: string | null | undefined): Crede
if (!raw) return null
const text = raw.toLowerCase()
// 京麦专属判据优先于通用终止句与 HTTP 401;仅探测登录态超时不是登录凭据失效。
if (/京麦未登录|未登录京麦|京麦登录态(?:已)?失效/.test(raw)
|| (raw.includes('京麦') && raw.includes('登录态失效') && !hit(text, SELF_HEALING_MARKERS))) {
return jdLoginNotice()
}
// 后端已经判死并写了指引句:这句话本身就足够定性,先认它(比逐词猜稳)
if (raw.includes(TERMINAL_SENTENCE)) {
return raw.includes(PROXY_TERMINAL_HINT) ? proxyNotice() : llmBalanceNotice()
@@ -137,6 +143,14 @@ export function credentialFatalNotice(message: string | null | undefined): Crede
return null
}
function jdLoginNotice(): CredentialFatalNotice {
return {
kind: 'jd_login',
title: '任务已中断:京麦未登录',
body: '请在客户端重新登录京麦,再回到任务面板重试。',
}
}
export function proxyNotice(): CredentialFatalNotice {
return {
kind: 'proxy',
@@ -26,6 +26,15 @@ test('同一任务同一档只入队一次(重复轮询/重进页面都吃掉
assert.equal(credentialFatalQueueLength(), 1)
})
test('同一京麦任务的未登录提示出队后也不重复弹', () => {
__resetCredentialFatalAlertForTest()
assert.equal(reportCredentialFatal(88, '京麦接口限流'), false)
assert.equal(reportCredentialFatal(88, '京麦未登录'), true)
assert.equal(takeCredentialFatal()?.notice.kind, 'jd_login')
assert.equal(reportCredentialFatal(88, '京麦登录态已失效,请重新登录'), false)
assert.equal(credentialFatalQueueLength(), 0)
})
test('同一任务换了一档要再弹(要去改的是另一处)', () => {
__resetCredentialFatalAlertForTest()
assert.equal(reportCredentialFatal(32901, '用户未配置代理'), true)
@@ -68,6 +68,26 @@ test('可自愈的供应商状态一律不弹', () => {
}
})
test('京麦未登录和登录态失效提示去客户端重新登录', () => {
for (const message of [
'京麦未登录(登录态失效),请在客户端重新登录京麦后重试',
'京麦登录态失效,任务已终止,请在客户端重新登录京麦',
'未登录京麦',
'京麦登录态已失效(HTTP 401)',
]) {
const notice = credentialFatalNotice(message)
assert.equal(notice?.kind, 'jd_login')
assert.equal(notice?.title, '任务已中断:京麦未登录')
assert.match(notice?.body ?? '', /请在客户端重新登录京麦/)
}
})
test('京麦限流、页面结构变化和未注明京麦的登录错误不弹京麦提示', () => {
for (const message of ['京麦接口限流', '京麦登录态检查超时', '京麦发布页面结构变更', '登录态失效']) {
assert.equal(kindOf(message), null, `误弹: ${message}`)
}
})
test('没有凭据字样的失败不弹(抖动不是凭据问题)', () => {
assert.equal(kindOf('LLM 网关无应答'), null)
assert.equal(kindOf('扩展注入失败'), null)
+1 -4
View File
@@ -339,12 +339,9 @@ test('test_endpoints_frozen_snapshot', () => {
"progressBatch": "/api/jd-collect/tasks/progress/batch",
"deleteTask": "/api/jd-collect/tasks/{taskId}"
},
// 2026-11-18 v1.5 Phase 4:京东商品上架(建单/激活/选品/面板七件)。建单响应 queuePayload
// 由服务端组装(type=jd-product-publish-run 与 SPI 同值,铁律 32 第三件),页面原样投
// api.enqueue_json;分类读取唯一来源仍是 jdCollect.groups(B113-01,AC-9 源码绊线钉死)。
// 京东商品上架:网页建单后只原样投递 queuePayload,客户端与后端负责认领。
"jdPublish": {
"create": "/api/jd-publish/tasks",
"activate": "/api/jd-publish/tasks/{taskId}/activate",
"products": "/api/jd-publish/products",
"dashboard": "/api/jd-publish/dashboard",
"history": "/api/jd-publish/history",
@@ -0,0 +1,191 @@
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(),
}))
vi.mock('@/shared/api/types/modules/jd-collect', () => ({ fetchJdCollectGroups: api.groups }))
vi.mock('@/shared/api/types/modules/jd-publish', () => ({
createJdPublishTask: api.create,
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() },
}))
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 = '京麦未登录(登录态失效),请在客户端重新登录京麦后重试'
function row(taskStatus: string, resumeAttempt: number, errorMessage?: string) {
return { taskId: 88, taskStatus, resumeAttempt, productTotal: 2, 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) {
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({ enqueue_json: api.enqueue })
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(api.create).toHaveBeenCalledOnce()
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.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('.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()
})