order_site/apps/frontend/tests/admin-realtime-work-orders.test.ts

import assert from 'node:assert/strict'
import test from 'node:test'

import {
  evaluateAdminWorkOrderRealtimeMatch,
  parseAdminWorkOrderListFilters,
  patchAdminWorkOrderListItems,
  shouldPrependAdminWorkOrder,
  type AdminWorkOrderListFilters,
} from '../src/utils/admin-realtime-work-orders.ts'

/** 复刻 WorkOrdersPanel 的结构化 queryKey。 */
function buildQueryKey(overrides: Partial<AdminWorkOrderListFilters> = {}) {
  const filters: AdminWorkOrderListFilters = {
    statuses: '',
    keyword: '',
    workerId: 0,
    categoryId: 0,
    workerLevelIds: '',
    targetWorkOrderId: 0,
    acceptanceMode: '',
    giftPhase: '',
    page: 1,
    createdFrom: '',
    createdTo: '',
    ...overrides,
  }
  return [
    'admin-worker-platform-orders',
    {
      statuses: filters.statuses,
      keyword: filters.keyword,
      workerId: filters.workerId,
      categoryId: filters.categoryId,
      workerLevelIds: filters.workerLevelIds,
      targetWorkOrderId: filters.targetWorkOrderId,
      acceptanceMode: filters.acceptanceMode,
      giftPhase: filters.giftPhase,
      page: filters.page,
      pageSize: 20,
      createdFrom: filters.createdFrom,
      createdTo: filters.createdTo,
    },
  ] as const
}

function buildSnapshot(overrides: Record<string, unknown> = {}) {
  return {
    workOrderId: 100,
    status: 'in_progress',
    rawStatus: 'in_progress',
    productName: '安卓暗潮3钻 苏尔南',
    platformOrderId: '2627291924608680',
    createdAt: '2026-09-29T10:51:05.000Z',
    material: { consignment: { inventoryId: 23, inventoryNo: 'INV26091917439822' } },
    ...overrides,
  }
}

function buildEnvelope(items: unknown[]) {
  return { ok: true, data: { items, pagination: { total: 124, page: 1, pageSize: 20 } } }
}

function itemsOfWorkOrders(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('状态筛选必须按原始状态判定：拼单母单的运营态不会把行误删', () => {
  const filters = parseAdminWorkOrderListFilters(buildQueryKey({ statuses: 'open' }))!
  // 拼单母单：原始 wo.status = open（列表筛选用它），但快照的 status 被显示成 in_progress
  const sharingMasterOrder = buildSnapshot({ status: 'in_progress', rawStatus: 'open' })
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(sharingMasterOrder, filters),
    'match',
    '拿运营态比会误判成 mismatch 并把行从列表里删掉',
  )

  // 反过来：原始状态确实不符仍然要能证伪
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(
      buildSnapshot({ status: 'open', rawStatus: 'accepted' }),
      filters,
    ),
    'mismatch',
  )
})

test('状态列表里的虚拟值「VIP 待补图」不可证真：不插不移', () => {
  const filters = parseAdminWorkOrderListFilters(
    buildQueryKey({ statuses: 'vip_evidence_pending' }),
  )!
  assert.equal(evaluateAdminWorkOrderRealtimeMatch(buildSnapshot(), filters), 'unknown')

  // 与真实状态混选时，服务端是「真实状态命中 OR VIP 待补图命中」：
  // 任何一行都可能通过 VIP 分支被救回来，所以整条状态筛选都不可证伪，一律 unknown（宁可不删）。
  const mixed = parseAdminWorkOrderListFilters(
    buildQueryKey({ statuses: 'open,vip_evidence_pending' }),
  )!
  for (const rawStatus of ['open', 'accepted', 'cancelled']) {
    assert.equal(
      evaluateAdminWorkOrderRealtimeMatch(buildSnapshot({ rawStatus }), mixed),
      'unknown',
      `${rawStatus} 仍可能通过 VIP 分支命中，不能判为 mismatch`,
    )
  }
})

test('实时补丁：只认结构化 queryKey，旧的下标数组一律不猜（返回 null）', () => {
  // 老结构：['admin-worker-platform-orders', statuses, keyword, workerId, categoryId, ...]
  const legacyKey = ['admin-worker-platform-orders', '', '', 0, 0, '', 0, '', '', 1, 20, '', '']
  assert.equal(parseAdminWorkOrderListFilters(legacyKey), null)

  const parsed = parseAdminWorkOrderListFilters(
    buildQueryKey({ page: 3, statuses: 'open,problem' }),
  )
  assert.ok(parsed)
  assert.equal(parsed!.page, 3, 'page 必须按名字读出来（原来被读成 targetWorkOrderId → 恒为 1）')
  assert.deepEqual(parsed!.statuses, ['open', 'problem'])
})

test('「内部寄售匹配」筛选下：普通单不会因为实时事件被插进列表', () => {
  const key = buildQueryKey({ acceptanceMode: 'internal_consignment', page: 1 })
  const filters = parseAdminWorkOrderListFilters(key)!
  assert.ok(filters)

  // 验收模式筛选前端无法证真 → unknown：既不能插入，也不能把已有行移除
  const ordinary = buildSnapshot({ workOrderId: 999, material: { collect: {} } })
  assert.equal(evaluateAdminWorkOrderRealtimeMatch(ordinary, filters), 'unknown')

  const envelope = buildEnvelope([buildSnapshot({ workOrderId: 100 })])
  const patched = patchAdminWorkOrderListItems(envelope, ordinary, { remove: false, insert: false })
  assert.equal(patched, envelope, '无法证真时不应改动列表')
  assert.equal(itemsOfWorkOrders(patched).length, 1)
})

test('第 2 页及以后绝不插入（原来任何页都被当成第 1 页，是乱跳的直接原因）', () => {
  const filters = parseAdminWorkOrderListFilters(buildQueryKey({ page: 2 }))!
  assert.equal(filters.page, 2)
  assert.equal(evaluateAdminWorkOrderRealtimeMatch(buildSnapshot(), filters), 'match')

  // 即使判定为 match，page !== 1 也不允许插到顶部
  const page2Items = [buildSnapshot({ workOrderId: 80 }), buildSnapshot({ workOrderId: 79 })]
  const fresh = buildSnapshot({ workOrderId: 5000 })
  const envelope = buildEnvelope(page2Items)
  const patched = patchAdminWorkOrderListItems(envelope, fresh, {
    remove: false,
    insert: filters.page === 1 && shouldPrependAdminWorkOrder(page2Items, fresh),
  })
  assert.equal(patched, envelope, '第 2 页不应被插入新行')
})

test('历史老单（id 小于首行）不会被插到列表顶部', () => {
  const items = [buildSnapshot({ workOrderId: 100 }), buildSnapshot({ workOrderId: 99 })]
  const legacy = buildSnapshot({ workOrderId: 42 })
  assert.equal(shouldPrependAdminWorkOrder(items, legacy), false)

  const envelope = buildEnvelope(items)
  const patched = patchAdminWorkOrderListItems(envelope, legacy, { remove: false, insert: false })
  assert.equal(patched, envelope, '排序不该变化：老单不进当前页')
})

test('真正的新单（id 大于首行）可以插到顶部，并同步分页总数', () => {
  const items = [buildSnapshot({ workOrderId: 100 })]
  const fresh = buildSnapshot({ workOrderId: 101 })
  assert.equal(shouldPrependAdminWorkOrder(items, fresh), true)

  const patched = patchAdminWorkOrderListItems(buildEnvelope(items), fresh, {
    remove: false,
    insert: true,
  })
  assert.deepEqual(
    itemsOfWorkOrders(patched).map((item) => item.workOrderId),
    [101, 100],
  )
  assert.equal(totalOf(patched), 125)
})

test('已存在的行只做原地替换，不改变位置', () => {
  const items = [
    buildSnapshot({ workOrderId: 100 }),
    buildSnapshot({ workOrderId: 99, status: 'open' }),
    buildSnapshot({ workOrderId: 98 }),
  ]
  const updated = buildSnapshot({ workOrderId: 99, status: 'in_progress' })
  const patched = patchAdminWorkOrderListItems(buildEnvelope(items), updated, {
    remove: false,
    insert: true,
  })
  assert.deepEqual(
    itemsOfWorkOrders(patched).map((item) => item.workOrderId),
    [100, 99, 98],
    '原地替换不能把它提到第一位',
  )
  assert.equal(totalOf(patched), 124, '行数没变，总数不能变')
})

test('状态筛选：已不命中的工单会被移除并扣减总数', () => {
  const filters = parseAdminWorkOrderListFilters(buildQueryKey({ statuses: 'open' }))!
  const accepted = buildSnapshot({ workOrderId: 100, status: 'accepted' })
  assert.equal(evaluateAdminWorkOrderRealtimeMatch(accepted, filters), 'mismatch')

  const patched = patchAdminWorkOrderListItems(
    buildEnvelope([
      buildSnapshot({ workOrderId: 100, status: 'open' }),
      buildSnapshot({ workOrderId: 99 }),
    ]),
    accepted,
    { remove: true, insert: false },
  )
  assert.deepEqual(
    itemsOfWorkOrders(patched).map((item) => item.workOrderId),
    [99],
  )
  assert.equal(totalOf(patched), 123)
})

test('打手 / 分类 / 工单号 / 创建日期筛选的证伪能力', () => {
  const filters = parseAdminWorkOrderListFilters(
    buildQueryKey({
      workerId: 7,
      categoryId: 12,
      targetWorkOrderId: 0,
      createdFrom: '2026-09-01',
      createdTo: '2026-09-30',
    }),
  )!

  // 指派给别的打手 → mismatch
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(buildSnapshot({ worker: { workerId: 8 } }), filters),
    'mismatch',
  )
  // 拼单参与者是目标打手 → 命中（后端 workerId 筛选也认拼单参与者）
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(
      buildSnapshot({ sharingWorkers: [{ workerId: 7 }], categoryId: 12 }),
      filters,
    ),
    'match',
  )
  // 分类不等：可能命中所选分类的**子分类**，而快照不带 parentCategoryId → 不能证伪，只能 unknown
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(
      buildSnapshot({ worker: { workerId: 7 }, categoryId: 99 }),
      filters,
    ),
    'unknown',
  )
  // 创建时间在范围外 → mismatch
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(
      buildSnapshot({
        worker: { workerId: 7 },
        categoryId: 12,
        createdAt: '2026-08-01T00:00:00.000Z',
      }),
      filters,
    ),
    'mismatch',
  )
})

test('关键词 / 赠送阶段 / 打手等级筛选：无法证真，只原地更新不插不移', () => {
  for (const override of [
    { keyword: '暗潮' },
    { giftPhase: 'gift_ready' },
    { workerLevelIds: '1,2' },
  ] as const) {
    const filters = parseAdminWorkOrderListFilters(buildQueryKey(override))!
    assert.equal(
      evaluateAdminWorkOrderRealtimeMatch(buildSnapshot(), filters),
      'unknown',
      `${JSON.stringify(override)} 应判为 unknown`,
    )
  }

  // 但「状态已经不匹配」这种可以证伪的条件优先级更高，仍要能移除
  const filters = parseAdminWorkOrderListFilters(
    buildQueryKey({ keyword: '暗潮', statuses: 'open' }),
  )!
  assert.equal(
    evaluateAdminWorkOrderRealtimeMatch(buildSnapshot({ status: 'accepted' }), filters),
    'mismatch',
  )
})