528 lines
20 KiB
TypeScript
528 lines
20 KiB
TypeScript
import assert from 'node:assert/strict'
|
|
import test from 'node:test'
|
|
|
|
import {
|
|
compareWorkerHallOrderRows,
|
|
evaluateWorkerKeywordVerdict,
|
|
matchesWorkerWorkOrderKeyword,
|
|
patchWorkerHallPersonalShares,
|
|
patchWorkerWorkOrderInfiniteEnvelope,
|
|
patchWorkerWorkOrderListEnvelope,
|
|
resolveWorkerMyOrderRealtimeVerdict,
|
|
} from '../src/utils/worker-realtime-work-orders.ts'
|
|
|
|
function buildRow(overrides: Record<string, unknown> = {}) {
|
|
return {
|
|
workOrderId: 9001,
|
|
workOrderNo: 'WO26093017345168',
|
|
status: 'in_progress',
|
|
productName: '某游戏代练',
|
|
platformOrderId: '2609301734',
|
|
material: { collect: { fields: { gameId: 'g-1', gameNickname: '小明' } } },
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function buildEnvelope(items: unknown[], total = items.length) {
|
|
return { ok: true, data: { items, pagination: { page: 1, pageSize: 20, total } } }
|
|
}
|
|
|
|
function itemsOf(envelope: unknown): Array<{ workOrderId: number }> {
|
|
return (envelope as { data: { items: Array<{ workOrderId: number }> } }).data.items
|
|
}
|
|
|
|
function totalOf(envelope: unknown): number {
|
|
return (envelope as { data: { pagination: { total: number } } }).data.pagination.total
|
|
}
|
|
|
|
test('按工单号搜索必须能命中（后端搜索串第一项就是工单号，前端曾完全没比对它）', () => {
|
|
assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), 'WO26093017345168'), true)
|
|
assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), 'wo26093017'), true)
|
|
// 原有字段仍然要能命中
|
|
assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), '小明'), true)
|
|
assert.equal(matchesWorkerWorkOrderKeyword(buildRow(), '2609301734'), true)
|
|
})
|
|
|
|
test('关键词维度：找不到只能是 unknown，绝不能当成"不匹配"（这才是行被删空的根因）', () => {
|
|
const row = buildRow()
|
|
assert.equal(evaluateWorkerKeywordVerdict(row, 'WO26093017345168'), 'match')
|
|
assert.equal(evaluateWorkerKeywordVerdict(row, ''), 'match')
|
|
// 后端还能搜 material_json 里前端不知道的字段，所以找不到 ≠ 不匹配
|
|
assert.equal(evaluateWorkerKeywordVerdict(row, '后端才知道的字段'), 'unknown')
|
|
})
|
|
|
|
test('按工单号搜到的行，实时事件来了也不能被删掉，并且总数要跟着走', () => {
|
|
const row = buildRow({ status: 'pending_material' })
|
|
const envelope = buildEnvelope([row])
|
|
const snapshot = buildRow({ status: 'in_progress' })
|
|
|
|
// 关键词命中 → upsert，原地更新，行数不变
|
|
const updated = patchWorkerWorkOrderListEnvelope(
|
|
envelope,
|
|
{ operation: 'upsert', data: snapshot },
|
|
false,
|
|
)
|
|
assert.equal(itemsOf(updated).length, 1)
|
|
assert.equal(totalOf(updated), 1)
|
|
assert.equal((itemsOf(updated)[0] as { status?: string }).status, 'in_progress')
|
|
})
|
|
|
|
test('大厅轻量快照就地更新时保留 myShare 等个性化字段', () => {
|
|
const envelope = buildEnvelope([
|
|
buildRow({ status: 'open', myShare: { quantity: 2 }, categoryName: '密钥' }),
|
|
])
|
|
const updated = patchWorkerWorkOrderListEnvelope(
|
|
envelope,
|
|
{
|
|
operation: 'upsert',
|
|
data: { workOrderId: 9001, status: 'open', productName: '新商品名' },
|
|
},
|
|
false,
|
|
)
|
|
const item = itemsOf(updated)[0] as {
|
|
productName?: string
|
|
myShare?: { quantity?: number }
|
|
categoryName?: string
|
|
}
|
|
assert.equal(item.productName, '新商品名')
|
|
assert.equal(item.myShare?.quantity, 2, '广播不带 myShare 时不能把已拼份额覆盖掉')
|
|
assert.equal(item.categoryName, '密钥')
|
|
})
|
|
|
|
test('不可证真的关键词下，快照只能就地更新：不插入、不删除', () => {
|
|
const envelope = buildEnvelope([buildRow()])
|
|
// 关键词没命中前端已知字段（unknown）：既不该把它当"不匹配"删掉
|
|
const patched = patchWorkerWorkOrderListEnvelope(
|
|
envelope,
|
|
{ operation: 'upsert', data: buildRow({ status: 'accepted' }) },
|
|
false,
|
|
)
|
|
assert.equal(itemsOf(patched).length, 1)
|
|
// 也不该把不在列表里的行插进来（留着让后端说了算）
|
|
const notInserted = patchWorkerWorkOrderListEnvelope(
|
|
envelope,
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 8888 }) },
|
|
false,
|
|
)
|
|
assert.equal(itemsOf(notInserted).length, 1)
|
|
})
|
|
|
|
test('真正移出可见范围时要删行，并同步分页总数（旧实现只删 items，分页器还显示有 N 条）', () => {
|
|
const envelope = buildEnvelope([buildRow(), buildRow({ workOrderId: 9002 })], 2)
|
|
const removed = patchWorkerWorkOrderListEnvelope(
|
|
envelope,
|
|
{ operation: 'remove', data: buildRow() },
|
|
false,
|
|
)
|
|
assert.deepEqual(
|
|
itemsOf(removed).map((item) => item.workOrderId),
|
|
[9002],
|
|
)
|
|
assert.equal(totalOf(removed), 1, '删行后总数必须减一')
|
|
|
|
const inserted = patchWorkerWorkOrderListEnvelope(
|
|
buildEnvelope([buildRow()], 1),
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 9003 }) },
|
|
true,
|
|
)
|
|
assert.equal(itemsOf(inserted).length, 2)
|
|
assert.equal(totalOf(inserted), 2, '插行后总数必须加一')
|
|
})
|
|
|
|
test('无限下拉：只有第 1 页允许插入，其余页只就地更新', () => {
|
|
const page = (ids: number[]) =>
|
|
buildEnvelope(ids.map((id) => buildRow({ workOrderId: id, status: 'open' })))
|
|
const current = { pages: [page([1, 2]), page([3, 4])], pageParams: [1, 2] }
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
current,
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 99, status: 'open' }) },
|
|
true,
|
|
) as { pages: unknown[] }
|
|
assert.equal(itemsOf(patched.pages[0]).length, 3, '第 1 页应插入')
|
|
assert.equal(itemsOf(patched.pages[1]).length, 2, '第 2 页不得插入')
|
|
})
|
|
|
|
test('大厅新单插入后，置顶单必须仍在最前方', () => {
|
|
const current = {
|
|
pages: [
|
|
buildEnvelope([
|
|
buildRow({ workOrderId: 100, status: 'open', pinnedAt: '2026-10-25T10:00:00+08:00' }),
|
|
buildRow({ workOrderId: 200, status: 'open' }),
|
|
]),
|
|
],
|
|
pageParams: [1],
|
|
}
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
current,
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 300, status: 'open' }) },
|
|
true,
|
|
) as { pages: unknown[] }
|
|
assert.deepEqual(
|
|
itemsOf(patched.pages[0]).map((item) => item.workOrderId),
|
|
[100, 300, 200],
|
|
'新单必须排在置顶单之后，未置顶部分仍按 id 倒序',
|
|
)
|
|
})
|
|
|
|
test('多个置顶单之间按置顶时间倒序，且都排在普通单之前', () => {
|
|
const current = {
|
|
pages: [
|
|
buildEnvelope([
|
|
buildRow({ workOrderId: 100, status: 'open', pinnedAt: '2026-10-25T09:00:00+08:00' }),
|
|
buildRow({ workOrderId: 200, status: 'open' }),
|
|
buildRow({ workOrderId: 300, status: 'open', pinnedAt: '2026-10-25T11:00:00+08:00' }),
|
|
]),
|
|
],
|
|
pageParams: [1],
|
|
}
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
current,
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 400, status: 'open' }) },
|
|
true,
|
|
) as { pages: unknown[] }
|
|
assert.deepEqual(
|
|
itemsOf(patched.pages[0]).map((item) => item.workOrderId),
|
|
[300, 100, 400, 200],
|
|
)
|
|
})
|
|
|
|
test('第 2 页的工单被置顶后必须提到第 1 页最前', () => {
|
|
const current = {
|
|
pages: [
|
|
buildEnvelope([
|
|
buildRow({ workOrderId: 300, status: 'open' }),
|
|
buildRow({ workOrderId: 299, status: 'open' }),
|
|
]),
|
|
buildEnvelope([buildRow({ workOrderId: 100, status: 'open' })]),
|
|
],
|
|
pageParams: [1, 2],
|
|
}
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
current,
|
|
{
|
|
operation: 'upsert',
|
|
data: buildRow({
|
|
workOrderId: 100,
|
|
status: 'open',
|
|
pinnedAt: '2026-10-25T12:00:00+08:00',
|
|
}),
|
|
},
|
|
false,
|
|
) as { pages: unknown[] }
|
|
assert.deepEqual(
|
|
itemsOf(patched.pages[0]).map((item) => item.workOrderId),
|
|
[100, 300],
|
|
'置顶单要在第 1 页最前，被顶下去的普通单顺延到第 2 页',
|
|
)
|
|
assert.deepEqual(
|
|
itemsOf(patched.pages[1]).map((item) => item.workOrderId),
|
|
[299],
|
|
)
|
|
})
|
|
|
|
/**
|
|
* 「我的订单」状态页签的实时删行判定。
|
|
*
|
|
* 生产现象（与后台同源）：按工单号搜出来的那一单，状态一流转（代练中 → 待验收 / 已验收）
|
|
* 就被实时补丁按"状态不匹配"删掉，列表变空、必须刷新整页。
|
|
* 页签只是展示偏好：后端按单号查时已经忽略状态，前端不能再拿状态删行。
|
|
*/
|
|
test('显式单号检索：状态页签不匹配也不得删行（状态流转后仍要能搜到）', () => {
|
|
const row = buildRow({ status: 'in_progress' })
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'pending_acceptance' }),
|
|
statusFilter: 'in_progress',
|
|
keyword: 'WO26093017345168',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: true,
|
|
})
|
|
assert.equal(verdict.operation, 'upsert', '单号检索下状态不能证伪')
|
|
assert.equal(verdict.shouldInsert, true, '命中的单号仍可插入第 1 页')
|
|
|
|
const updated = patchWorkerWorkOrderListEnvelope(
|
|
buildEnvelope([row]),
|
|
{ operation: verdict.operation, data: buildRow({ status: 'pending_acceptance' }) },
|
|
verdict.shouldInsert,
|
|
)
|
|
assert.equal(itemsOf(updated).length, 1, '行不能被删掉')
|
|
assert.equal(
|
|
(itemsOf(updated)[0] as { status?: string }).status,
|
|
'pending_acceptance',
|
|
'应就地更新成最新状态',
|
|
)
|
|
})
|
|
|
|
test('模糊关键词：状态页签不匹配仍按原设计移除行', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'accepted' }),
|
|
statusFilter: 'in_progress',
|
|
keyword: '暗潮',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(verdict.operation, 'remove')
|
|
assert.equal(verdict.shouldInsert, false)
|
|
})
|
|
|
|
test('服务端 remove（打手已失去该单）仍然生效，单号护栏不误挡', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'in_progress' }),
|
|
statusFilter: '',
|
|
keyword: 'WO26093017345168',
|
|
operation: 'remove',
|
|
page: 1,
|
|
explicitOrderNo: true,
|
|
})
|
|
assert.equal(verdict.operation, 'remove', '服务端明确说单子已不可见时必须移除')
|
|
})
|
|
|
|
test('非第 1 页不得插入，只做就地更新', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ workOrderId: 8888 }),
|
|
statusFilter: '',
|
|
keyword: 'WO26093017345168',
|
|
operation: 'upsert',
|
|
page: 2,
|
|
explicitOrderNo: true,
|
|
})
|
|
assert.equal(verdict.operation, 'upsert')
|
|
assert.equal(verdict.shouldInsert, false)
|
|
})
|
|
|
|
/**
|
|
* 同一打手在同一个工单多次拼单：一张单可以同时属于「代练中」和「待验收」，
|
|
* 但快照的 status 只能是一个值。前端若按单个 status 删行，另一个页签就会莫名其妙变空
|
|
* （线上「待验收有时候没有数据」）。服务端现在带 workerStatuses，按集合判归属。
|
|
*/
|
|
test('多份额工单：快照 status 是进行中，但属于待验收时不得从待验收页签删行', () => {
|
|
const snapshot = buildRow({
|
|
status: 'in_progress',
|
|
workerStatuses: ['in_progress', 'pending_acceptance'],
|
|
})
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: snapshot,
|
|
statusFilter: 'pending_acceptance',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(verdict.operation, 'upsert', '待验收页签必须保留这张多份额工单')
|
|
assert.equal(verdict.shouldInsert, true)
|
|
|
|
const updated = patchWorkerWorkOrderListEnvelope(
|
|
buildEnvelope([buildRow({ status: 'pending_acceptance' })]),
|
|
{ operation: verdict.operation, data: snapshot },
|
|
verdict.shouldInsert,
|
|
)
|
|
assert.equal(itemsOf(updated).length, 1)
|
|
assert.equal((itemsOf(updated)[0] as { status?: string }).status, 'in_progress')
|
|
})
|
|
|
|
test('多份额工单：workerStatuses 同时也是代练中页签的归属依据', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({
|
|
status: 'in_progress',
|
|
workerStatuses: ['in_progress', 'pending_acceptance'],
|
|
}),
|
|
statusFilter: 'in_progress',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(verdict.operation, 'upsert')
|
|
})
|
|
|
|
test('不在页签集合里时才允许删行（例如已验收后离开待验收页签）', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'accepted', workerStatuses: ['accepted'] }),
|
|
statusFilter: 'pending_acceptance',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(verdict.operation, 'remove')
|
|
assert.equal(verdict.shouldInsert, false)
|
|
})
|
|
|
|
test('VIP 待补图页签也靠 workerStatuses 判定，不会被当成状态不符删掉', () => {
|
|
const verdict = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'accepted', workerStatuses: ['accepted', 'vip_evidence_pending'] }),
|
|
statusFilter: 'vip_evidence_pending',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(verdict.operation, 'upsert')
|
|
})
|
|
|
|
test('没有 workerStatuses 的旧快照仍按单个 status 比对（保持既有行为）', () => {
|
|
const mismatch = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'accepted' }),
|
|
statusFilter: 'pending_acceptance',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(mismatch.operation, 'remove')
|
|
|
|
const match = resolveWorkerMyOrderRealtimeVerdict({
|
|
item: buildRow({ status: 'pending_acceptance' }),
|
|
statusFilter: 'pending_acceptance',
|
|
keyword: '',
|
|
operation: 'upsert',
|
|
page: 1,
|
|
explicitOrderNo: false,
|
|
})
|
|
assert.equal(match.operation, 'upsert')
|
|
})
|
|
|
|
/**
|
|
* 大厅按钮需求：拼过一次后按钮固定显示「再拼一次」，不再随次数变化。
|
|
* 这依赖 myShare/myShares 一直留在行上；而大厅广播是「所有打手通用」的快照，
|
|
* 不含个人份额，覆盖行时必须保留，否则按钮会被冲回「拼单 ￥x/份」。
|
|
*/
|
|
test('大厅广播覆盖行时必须保留本打手的 myShare/myShares，并更新拼单进度', () => {
|
|
const cachedRow = buildRow({
|
|
status: 'open',
|
|
myShare: { shareId: 77, quantity: 1, status: 'joined' },
|
|
myShares: [{ shareId: 77, quantity: 1, status: 'joined' }],
|
|
sharingProgress: { joinedQuantity: 1, pendingSubmissionCount: 1 },
|
|
})
|
|
const envelope = { pages: [buildEnvelope([cachedRow])], pageParams: [1] }
|
|
const snapshot = buildRow({
|
|
status: 'open',
|
|
sharingProgress: { joinedQuantity: 2, pendingSubmissionCount: 2 },
|
|
})
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
envelope,
|
|
{ operation: 'upsert', data: snapshot },
|
|
true,
|
|
['myShare', 'myShares'],
|
|
) as { pages: unknown[] }
|
|
const row = itemsOf(patched.pages[0])[0] as {
|
|
myShare?: { shareId: number }
|
|
myShares?: unknown[]
|
|
sharingProgress?: { joinedQuantity: number }
|
|
}
|
|
assert.equal(row.myShare?.shareId, 77, '不能把「再拼一次」的依据冲掉')
|
|
assert.equal(row.myShares?.length, 1)
|
|
assert.equal(row.sharingProgress?.joinedQuantity, 2, '公开进度仍要用广播里的最新值')
|
|
|
|
// 新插入的行本来就不属于我，不能凭空补上旧字段
|
|
const inserted = patchWorkerWorkOrderInfiniteEnvelope(
|
|
envelope,
|
|
{ operation: 'upsert', data: buildRow({ workOrderId: 9999, status: 'open' }) },
|
|
true,
|
|
['myShare', 'myShares'],
|
|
) as { pages: unknown[] }
|
|
const insertedRow = itemsOf(inserted.pages[0]).find((item) => item.workOrderId === 9999) as
|
|
| { myShare?: unknown; myShares?: unknown }
|
|
| undefined
|
|
assert.equal(insertedRow?.myShare ?? null, null)
|
|
assert.equal(insertedRow?.myShares ?? null, null)
|
|
})
|
|
|
|
test('旧版大厅广播显式带 null/[] 时也不能冲掉本打手份额', () => {
|
|
const cachedRow = buildRow({
|
|
status: 'open',
|
|
myShare: { shareId: 88, quantity: 2, status: 'joined' },
|
|
myShares: [{ shareId: 88, quantity: 2, status: 'joined' }],
|
|
sharingProgress: { joinedQuantity: 2, pendingSubmissionCount: 1 },
|
|
})
|
|
const envelope = { pages: [buildEnvelope([cachedRow])], pageParams: [1] }
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
envelope,
|
|
{
|
|
operation: 'upsert',
|
|
data: buildRow({
|
|
status: 'open',
|
|
myShare: null,
|
|
myShares: [],
|
|
sharingProgress: { joinedQuantity: 3 },
|
|
}),
|
|
},
|
|
true,
|
|
['myShare', 'myShares'],
|
|
) as { pages: unknown[] }
|
|
const row = itemsOf(patched.pages[0])[0] as {
|
|
myShare?: { shareId: number }
|
|
myShares?: unknown[]
|
|
sharingProgress?: { joinedQuantity: number }
|
|
}
|
|
assert.equal(row.myShare?.shareId, 88, '旧事件不能把「再拼一次」冲掉')
|
|
assert.equal(row.myShares?.length, 1)
|
|
assert.equal(row.sharingProgress?.joinedQuantity, 3, '公开进度仍取广播最新值')
|
|
})
|
|
|
|
test('「我的订单」快照回填大厅行个人份额：撤销份额后清空，找不到工单不改缓存', () => {
|
|
const joined = buildRow({
|
|
workOrderId: 5,
|
|
status: 'open',
|
|
myShare: { shareId: 66, quantity: 1, status: 'joined' },
|
|
myShares: [{ shareId: 66, quantity: 1, status: 'joined' }],
|
|
})
|
|
const envelope = { pages: [buildEnvelope([joined])], pageParams: [1] }
|
|
|
|
const cleared = patchWorkerHallPersonalShares(envelope, 5, null, []) as { pages: unknown[] }
|
|
const row = itemsOf(cleared.pages[0])[0] as { myShare?: unknown; myShares?: unknown[] }
|
|
assert.equal(row.myShare ?? null, null, '后台撤掉份额后大厅按钮要能恢复成「拼单」')
|
|
assert.deepEqual(row.myShares, [])
|
|
|
|
// 工单不在大厅缓存里时原样返回，不能凭空造行。
|
|
assert.equal(patchWorkerHallPersonalShares(envelope, 999, null, []), envelope)
|
|
})
|
|
|
|
/**
|
|
* 线上坑：进大厅后过一会儿「排名靠后的订单跑到前面去」。
|
|
*
|
|
* 根因是大厅广播补丁只做「就地覆盖 + 顶部插入」、不重排缓存：
|
|
* 1) 列表 SQL 按置顶时间排序时，广播快照没带 pinnedAt，排序口径直接丢失；
|
|
* 2) 广播 upsert 插到第 1 页顶部，会把已置顶的行挤到后面。
|
|
* 修复 = 后端快照带 pinnedAt + 前端按「置顶优先 → 工单号倒序」重排插行后的列表。
|
|
*/
|
|
test('大厅排序比较器：置顶行恒在未置顶行前，同置顶按置顶时间倒序', () => {
|
|
const pinnedNewer = buildRow({ workOrderId: 1, pinnedAt: '2026-10-24T10:00:00Z' })
|
|
const pinnedOlder = buildRow({ workOrderId: 2, pinnedAt: '2026-10-24T09:00:00Z' })
|
|
const unpinned = buildRow({ workOrderId: 3, pinnedAt: null })
|
|
|
|
assert.equal(compareWorkerHallOrderRows(pinnedNewer, pinnedOlder) < 0, true)
|
|
assert.equal(compareWorkerHallOrderRows(pinnedOlder, pinnedNewer) > 0, true)
|
|
assert.equal(compareWorkerHallOrderRows(pinnedNewer, unpinned) < 0, true)
|
|
assert.equal(compareWorkerHallOrderRows(unpinned, pinnedNewer) > 0, true)
|
|
// 双方都未置顶：按工单号倒序（与列表 SQL 的 id DESC 一致）
|
|
const newer = buildRow({ workOrderId: 10, pinnedAt: null })
|
|
const older = buildRow({ workOrderId: 9, pinnedAt: null })
|
|
assert.equal(compareWorkerHallOrderRows(newer, older) < 0, true)
|
|
})
|
|
|
|
test('广播 upsert 插入新行后必须按大厅口径重排，不能把置顶行挤下去', () => {
|
|
const pinnedRow = buildRow({
|
|
workOrderId: 100,
|
|
status: 'open',
|
|
pinnedAt: '2026-10-24T09:00:00Z',
|
|
})
|
|
const envelope = { pages: [buildEnvelope([pinnedRow])], pageParams: [1] }
|
|
const patched = patchWorkerWorkOrderInfiniteEnvelope(
|
|
envelope,
|
|
{
|
|
operation: 'upsert',
|
|
data: buildRow({ workOrderId: 200, status: 'open', pinnedAt: null }),
|
|
},
|
|
true,
|
|
['myShare', 'myShares'],
|
|
compareWorkerHallOrderRows,
|
|
) as { pages: unknown[] }
|
|
assert.deepEqual(
|
|
itemsOf(patched.pages[0]).map((item) => item.workOrderId),
|
|
[100, 200],
|
|
'新单排在置顶单后面，而不是插到最前面',
|
|
)
|
|
})
|