baiyue-firstleg/scripts/real-order-xlsx-test-env.test.mjs

import assert from 'node:assert/strict'
import test from 'node:test'
import { normalizeRows, channelName, matchRoute, measurementShape, buildSourceDraft, buildPayload,
  requireSuccess, executeCandidates, totalPreservingShapes, saveMeasurementDraft } from './real-order-xlsx-test-env.mjs'

const header = ['进仓编号', '客户', '渠道', '亚马逊仓', '实际件数', '实际毛重', '实际立方', '预报件数', '买单/退税', '品名', 'SKU', 'FBA货件编号', '跟踪编号']
const row = ['ABCD2606010001', 'Example', '合德海卡包税', 'ABC1', 31, 100, 2, 31, '买单', 'Goods', 'SKU1', 'SHIP1', 'REF1']
const order = () => normalizeRows([header, row]).orders[0]
const catalog = { receiving: { id: '1', warehouseName: 'Origin' },
  channels: [{ channelName: '合德海卡', channelCode: 'CHANNEL', pricingTaxModes: ['TAX_INCLUDED'] }],
  destinations: [{ id: '2', warehouseType: 'FBA', warehouseCode: 'ABC1', warehouseName: 'ABC1', countryCode: 'US' }] }

test('source counts remain actual, including after forecast differs', () => {
  const modified = [...row]; modified[7] = 99
  assert.equal(normalizeRows([header, modified]).orders[0].packageCount, 31)
})
test('missing and zero actual data do not fall back to forecast', () => {
  for (const missing of [null, '', 0]) {
    const modified = [...row]; modified[4] = missing
    assert.ok(normalizeRows([header, modified]).orders[0].problems.includes('MISSING_实际件数'))
  }
})
test('invalid source codes are excluded, not converted into orders', () => {
  const modified = [...row]; modified[0] = 'container subtotal'
  const actual = normalizeRows([header, modified])
  assert.equal(actual.orders.length, 0); assert.equal(actual.excluded.length, 1)
})
test('explicit declaration changes use the stated final mode', () => {
  for (const [source, target] of [['买单改退税', 'TAX_REFUND'], ['退税改买单', 'BUY_DECLARATION']]) {
    const modified = [...row]; modified[8] = source
    const result = normalizeRows([header, modified]).orders[0]
    assert.equal(result.taxMode, target); assert.deepEqual(result.problems, [])
  }
})
test('split rows aggregate actual counts once and reconcile forecast', () => {
  const a = [...row], b = [...row]; a[4] = 15; b[4] = 16
  const result = normalizeRows([header, a, b]).orders[0]
  assert.equal(result.packageCount, 31); assert.deepEqual(result.rows, [2, 3]); assert.deepEqual(result.problems, [])
  b[4] = 15
  assert.ok(normalizeRows([header, a, b]).orders[0].problems.includes('SPLIT_COUNT_MISMATCH'))
})
test('split weight and volume totals use the persisted order precision', () => {
  const a = [...row], b = [...row]
  a[4] = 90; b[4] = 300; a[7] = 390; b[7] = 390
  a[5] = 1137.461538; b[5] = 3791.538
  a[6] = 7.256538462; b[6] = 24.188
  const result = normalizeRows([header, a, b]).orders[0]
  assert.equal(result.weightKg, 4929)
  assert.equal(result.volumeCbm, 31.4445)
})
test('conflicting channels on same inbound code block import', () => {
  const b = [...row]; b[2] = '其他包税'
  assert.ok(normalizeRows([header, row, b]).orders[0].problems.includes('CONFLICT_渠道'))
})
test('channel suffix normalization never substitutes another base channel', () => {
  assert.equal(channelName('合德海派包税\n（FedEx）'), '合德海派')
  assert.equal(channelName('合德海卡不包税'), '合德海卡')
  assert.throws(() => matchRoute({ ...order(), channelName: 'Unknown' }, catalog))
})
test('excluded-tax estimation uses source billing unit and never guesses missing units', () => {
  const modified = [...row]; modified[2] = '合德海卡不包税'
  const columns = [...header, '单位']
  const result = normalizeRows([columns, [...modified, 'CBM']]).orders[0]
  assert.equal(result.chargeMode, 'CBM'); assert.deepEqual(result.problems, [])
  assert.ok(normalizeRows([columns, [...modified, '']]).orders[0].problems.includes('UNKNOWN_OR_CONFLICTING_CHARGE_MODE'))
})
test('ambiguous destinations and unavailable tax modes fail closed', () => {
  assert.throws(() => matchRoute(order(), { ...catalog, destinations: [...catalog.destinations, ...catalog.destinations] }))
  assert.throws(() => matchRoute({ ...order(), pricingTaxMode: 'TAX_EXCLUDED' }, catalog))
})
test('private addresses and dropship are explicit gaps, not random replacements', () => {
  assert.throws(() => matchRoute({ ...order(), destinationType: 'PRIVATE' }, catalog), /PRIVATE_ADDRESS/)
  assert.throws(() => matchRoute({ ...order(), fulfillmentType: 'ONE_CLICK_DROPSHIP' }, catalog), /WORK_PALLET/)
})
test('logical pallet count uses ceiling of boxes divided by 30', () => {
  for (const [boxes, expected] of [[1, 1], [30, 1], [31, 2], [300, 10], [1000, 34]]) {
    assert.equal(measurementShape({ ...order(), packageCount: boxes }).palletCount, expected)
  }
})
test('inferred groups conserve volume after ADD and server per-carton rounding', () => {
  const rules = [[30, 20, 20], [40, 30, 30], [50, 40, 40], [60, 50, 50]].map((dims, index) =>
    ({ boxType: String(index), innerLengthCm: dims[0], innerWidthCm: dims[1], innerHeightCm: dims[2], edgeAdditionCm: 2 }))
  for (const [packageCount, volumeCbm] of [[8, 0.403], [17, 1.545], [7, 0.626], [31, 2], [300, 23.457], [1, 0.1], [1000, 98.7654]]) {
    const plan = totalPreservingShapes({ ...order(), packageCount, volumeCbm }, rules)
    assert.ok(plan.length <= 2)
    assert.equal(plan.reduce((n, g) => n + g.count, 0), packageCount)
    const ticks = plan.reduce((n, g) => {
      const raw = Number(((g.length + 2 * g.edgeAdditionCm) ** 3 / 1e6).toFixed(6))
      return n + Math.ceil(raw * 10000 - 1e-8) * g.count
    }, 0)
    assert.equal(ticks, Math.round(volumeCbm * 10000))
    if (Number.isInteger(Math.round(volumeCbm * 1e6) / 1000)) {
      const detailWeight = plan.reduce((sum, group) => sum + Math.ceil(group.unitVolumeCbm * group.count * 167 * 1000 - 1e-8), 0)
      assert.equal(detailWeight, Math.ceil(volumeCbm * 167 * 1000 - 1e-8))
    }
  }
  assert.throws(() => totalPreservingShapes({ ...order(), volumeCbm: 0.123456 }, rules), /PRECISION/)
})
test('source-only draft does not invent measurement or product evidence', () => {
  const payload = buildSourceDraft(order(), matchRoute(order(), catalog), 'Example', 'MARKER')
  assert.equal(payload.cargoes[0].packageCount, 31)
  assert.equal(payload.cargoes[0].grossWeightKg, 100)
  assert.equal(payload.cargoes[0].volumeCbm, 2)
  assert.equal(payload.cargoes[0].woodenProduct, false)
  for (const key of ['lengthCm', 'productImageFileId', 'hsCode', 'dangerousGoods']) assert.equal(key in payload.cargoes[0], false)
})
test('simulated payload is labeled, preserving source measures without randomization', () => {
  const payload = buildPayload(order(), matchRoute(order(), catalog), 'Example', 'image', 'MARKER')
  assert.match(payload.customerRemark, /非真实测量证据/)
  assert.equal(payload.cargoes[0].volumeCbm, 2)
  assert.match(payload.cargoes[0].cargoRemark, /禁止用于真实报关/)
})
test('HTTP business errors preserve diagnostic evidence', () => {
  assert.throws(() => requireSuccess({ http: 200, path: '/example', body: { code: 'A0409' }, requestId: 'req' }),
    (error) => error.evidence.code === 'A0409' && error.evidence.requestId === 'req')
})
test('measurement draft retries a transient server error after refreshing the version', async () => {
  let reads = 0, writes = 0
  const retries = []
  const entry = { dimensionPlan: [{ itemId: 'item-1', count: 31, length: 40, width: 30, height: 30 }] }
  const api = async (method) => {
    if (method === 'GET') return { measurementId: 'measurement-1', version: ++reads,
      items: [{ id: 'item-1', inboundDetailId: 'detail-1', itemNo: 1, boxSpecification: 'TEST' }] }
    writes++
    if (writes === 1) { const error = Error('temporary'); error.evidence = { code: 'S0500', requestId: 'req-1' }; throw error }
    return { measurementId: 'measurement-1', version: 3 }
  }
  const result = await saveMeasurementDraft({ api, measurementPath: '/measurement', base: '/inbound/1', q: 'tenantId=1',
    order: order(), entry, marker: 'MARKER', wait: async () => {}, onRetry: async (retry) => retries.push(retry) })
  assert.equal(result.version, 3)
  assert.equal(reads, 2)
  assert.equal(writes, 2)
  assert.deepEqual(retries.map((retry) => retry.code), ['S0500'])
})
test('same batch never recreates an attempted order, even when interrupted', async () => {
  const value = order(), state = { identity: { batchId: 'test' }, orders: { [value.key]: { status: 'STARTED' } } }
  await executeCandidates({ candidates: [{ order: value, route: catalog }], limit: 1, state, save: async () => {},
    api: async () => { throw Error('must not call HTTP') } })
  assert.equal(state.lastRun.attempted, 0); assert.equal(state.lastRun.skipped, 1)
})
test('pending-review stage submits but never calls approval or measurement APIs', async () => {
  const value = order(), route = matchRoute(value, catalog)
  const state = { identity: { batchId: 'pending-review' }, orders: {} }
  const calls = []
  let detailReads = 0
  const api = async (method, path) => {
    calls.push(`${method} ${path}`)
    if (path.endsWith('/pricing/estimate')) return { channelCode: route.channel.channelCode, pricingTaxMode: value.pricingTaxMode }
    if (method === 'POST' && path === '/api/merchant/v1/orders/first-leg') return 'order-1'
    if (path === '/api/merchant/v1/orders/first-leg/order-1' && method === 'GET') {
      detailReads++
      return { order: { id: 'order-1', orderNo: 'FL-1', customerRemark: Object.values(state.orders)[0].marker,
        status: detailReads > 1 ? 'SUBMITTED' : 'DRAFT' },
      cargoes: [{ packageCount: value.packageCount, grossWeightKg: value.weightKg, volumeCbm: value.volumeCbm }] }
    }
    if (path === '/api/merchant/v1/orders/order-1') return { summary: { mainStatus: 'PENDING_REVIEW' } }
    if (method === 'POST' && path.endsWith('/submit')) return true
    throw Error(`unexpected call ${method} ${path}`)
  }
  await executeCandidates({ candidates: [{ order: value, route }], limit: 1, concurrency: 1, state,
    save: async () => {}, api, merchant: 'merchant', profile: { tenantName: 'Example' },
    sharedResources: { productImageFileId: 'image-1' }, stage: 'pending-review' })
  assert.equal(Object.values(state.orders)[0].stage, 'PENDING_REVIEW')
  assert.equal(Object.values(state.orders)[0].verification.mainStatus, 'PENDING_REVIEW')
  assert.equal(calls.some((call) => /approve|measurement|inbounds/.test(call)), false)
})
test('pending-review retries an estimate-only pricing failure and records it as a warning', async () => {
  const value = order(), route = matchRoute(value, catalog)
  const state = { identity: { batchId: 'pricing-warning' }, orders: { [value.key]: { status: 'FAILED', stage: 'estimate',
    error: 'HTTP_200_CODE_A0404', evidence: { code: 'A0404', requestId: 'old-request' }, finishedAt: '2026-01-01T00:00:00Z' } } }
  let detailReads = 0
  const api = async (method, path) => {
    if (path.endsWith('/pricing/estimate')) { const error = Error('no price'); error.evidence = { code: 'A0404', message: 'no price' }; throw error }
    if (method === 'POST' && path === '/api/merchant/v1/orders/first-leg') return 'order-2'
    if (path === '/api/merchant/v1/orders/first-leg/order-2' && method === 'GET') {
      detailReads++
      return { order: { id: 'order-2', orderNo: 'FL-2', customerRemark: Object.values(state.orders)[0].marker,
        status: detailReads > 1 ? 'SUBMITTED' : 'DRAFT' },
      cargoes: [{ packageCount: value.packageCount, grossWeightKg: value.weightKg, volumeCbm: value.volumeCbm }] }
    }
    if (path === '/api/merchant/v1/orders/order-2') return { summary: { mainStatus: 'PENDING_REVIEW' } }
    if (method === 'POST' && path.endsWith('/submit')) return true
    throw Error(`unexpected call ${method} ${path}`)
  }
  await executeCandidates({ candidates: [{ order: value, route }], limit: 1, concurrency: 1, state,
    save: async () => {}, api, merchant: 'merchant', profile: { tenantName: 'Example' },
    sharedResources: { productImageFileId: 'image-1' }, stage: 'pending-review' })
  const entry = state.orders[value.key]
  assert.equal(entry.status, 'SUCCEEDED')
  assert.equal(entry.pricingWarning.code, 'A0404')
  assert.equal(entry.priorAttempts.length, 1)
})
test('single process respects bounded concurrency while keeping per-order checkpoints', async () => {
  const base = order()
  const route = matchRoute(base, catalog)
  const candidates = Array.from({ length: 7 }, (_, index) => ({
    order: { ...base, key: `key-${index}`, sourceCode: `SRC-${index}`, rows: [index + 2] }, route,
  }))
  const state = { identity: { batchId: 'concurrency' }, orders: {} }
  let active = 0, maximum = 0, id = 0
  const api = async (method, path, body) => {
    if (path.endsWith('/pricing/estimate')) {
      active++; maximum = Math.max(maximum, active)
      await new Promise((resolve) => setTimeout(resolve, 5))
      active--
      return { channelCode: route.channel.channelCode, pricingTaxMode: base.pricingTaxMode }
    }
    if (method === 'POST') return String(++id)
    const marker = path.split('/').at(-1)
    return { order: { id: marker, orderNo: `ORDER-${marker}`, customerRemark: Object.values(state.orders)
      .find((entry) => entry.orderId === marker)?.marker }, cargoes: [{ packageCount: 31, grossWeightKg: 100, volumeCbm: 2 }] }
  }
  await executeCandidates({ candidates, limit: 7, concurrency: 3, state, save: async () => {}, api,
    profile: { tenantName: 'Example' }, stage: 'create' })
  assert.equal(maximum, 3)
  assert.equal(state.lastRun.attempted, 7)
  assert.equal(state.lastRun.succeeded, 7)
  assert.equal(Object.values(state.orders).filter((entry) => entry.status === 'SUCCEEDED').length, 7)
})