350 lines
26 KiB
JavaScript
350 lines
26 KiB
JavaScript
import test from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { plan, execute, executionOptions, validateManifest, fixtureSource, expectedRows, scale, verifyActual, runCase, redact,
|
|
multipartAdapter, requestInit, validateResumeProof, validateResumeLive, resumeMeasurementDraft, validateZeroWorkTask, validatePreparedResume,
|
|
originalCompletionCommand, verifyPhysicalFacts, verifyOldOwnersUnchanged, verifyDownstream } from './partial-loading-actual-test-env.mjs'
|
|
import { fileURLToPath } from 'node:url'
|
|
import { resolve } from 'node:path'
|
|
import { createServer } from 'node:http'
|
|
|
|
const runId = 'PARTIAL-ACTUAL-offline'
|
|
const evidence = Object.fromEntries(['PHOTO_STEP_1','PHOTO_STEP_2','PHOTO_STEP_3','PHOTO_STEP_4','SEAL'].map(type => [type, 'sample.png']))
|
|
function fixture(kind = 'B') {
|
|
const definitions = kind === 'B' ? [[1, 11, 2, 'BUY_DECLARATION'], [2, 22, 1, 'TAX_REFUND']]
|
|
: [[1, 11, 3, 'TAX_REFUND'], [2, 11, 1, 'TAX_REFUND'], [3, 22, 1, 'BUY_DECLARATION'], [4, 33, 1, 'TAX_REFUND']]
|
|
const task = { id: '91', loadingPlanId: '90', containerBookingId: '92', version: 0,
|
|
items: definitions.map(([n, tenant, count]) => ({ id: String(n), loadingPlanItemId: String(n + 100), tenantId: String(tenant),
|
|
inboundId: String(kind === 'A' && n === 2 ? 1 : n), inboundDetailId: String(n + 200), plannedPackageCount: count,
|
|
pickedPackageCount: 0, itemStatus: 'PENDING', unitType: 'PACKAGE', palletId: null, version: 0 })) }
|
|
const preload = { items: definitions.map(([n, tenant, count, tax]) => ({ itemId: String(n + 100), accountId: String(tenant),
|
|
inboundId: String(kind === 'A' && n === 2 ? 1 : n), inboundDetailId: String(n + 200), customsTaxMode: tax, orderId: String(n + 300),
|
|
packageCount: count, productQuantity: count * 7, unitsPerPackage: 7, grossWeightKg: '10.001', netWeightKg: '8.002', dimensionalWeightKg: '6.004', volumeCbm: '0.1001' })) }
|
|
const spec = { kind, sourceReport: `${kind}.json`, evidence, sealNo: 'SEAL-TEST', actions: definitions.map(([n]) => ({ itemId: String(n),
|
|
action: n === 1 ? 'PARTIAL' : kind === 'A' && n === 3 ? 'PICK' : 'SKIP', ...(n === 1 ? { finalPickedPackageCount: kind === 'A' ? 2 : 1 } : {}) })) }
|
|
const expected = expectedRows(spec, task, preload)
|
|
const actualItems = expected.filter(row => row.actual > 0).map(row => ({ ...row.frozen, packageCount: row.actual,
|
|
productQuantity: row.actual * 7, ...Object.fromEntries(['grossWeightKg','netWeightKg','dimensionalWeightKg','volumeCbm'].map(field =>
|
|
[field, scale(row.frozen[field], row.actual, row.planned, field === 'volumeCbm' ? 4 : 3)])) }))
|
|
const sum = (field, digits) => Number(actualItems.reduce((value, item) => value + BigInt(scale(item[field], 1, 1, digits).replace('.', '')), 0n)) / 10 ** digits
|
|
const detail = { items: actualItems, summary: { totalPackageCount: actualItems.reduce((sum, row) => sum + row.packageCount, 0),
|
|
totalQuantity: actualItems.reduce((sum, row) => sum + row.productQuantity, 0), totalGrossWeightKg: sum('grossWeightKg', 3),
|
|
totalNetWeightKg: sum('netWeightKg', 3), totalVolumeCbm: sum('volumeCbm', 4) } }
|
|
const customs = { actualBoxCount: detail.summary.totalPackageCount, inbounds: expected.filter(row => row.actual > 0),
|
|
taxRefundCount: kind === 'B' ? 0 : 1, version: 0, status: kind === 'B' ? 'READY_TO_START' : 'WAITING_CUSTOMER_DOCUMENTS' }
|
|
const source = { pdaTaskId: '91', loadingPlanId: '90', containerBookingId: '92', warehouseId: '1', sourceMarker: `${runId}-${kind}` }
|
|
return { task, preload, spec, expected, detail, customs, source }
|
|
}
|
|
|
|
test('default plan and --plan make zero network calls', async () => {
|
|
const original = globalThis.fetch
|
|
globalThis.fetch = () => { throw Error('No network in plan') }
|
|
try { assert.deepEqual(await execute([], [], {}), plan()); assert.equal((await execute(['--plan'], [], {})).networkRequests, 0) }
|
|
finally { globalThis.fetch = original }
|
|
})
|
|
|
|
test('execution refuses absent explicit TEST/profile/cwd', () => {
|
|
assert.throws(() => executionOptions(['--execute'], [], {}))
|
|
assert.throws(() => executionOptions(['--execute','--environment=TEST',`--run-id=${runId}`,'--fixture=x.json'], [], {}, 'C:/other'))
|
|
})
|
|
|
|
test('NEW mode uses the configured /api base and does not accept a bare origin', () => {
|
|
const cwd = fileURLToPath(new URL('..', import.meta.url))
|
|
const env = { CHONGCHONG_ENV: 'test', CHONGCHONG_ADMIN_API_BASE_URL: 'https://test.invalid/api',
|
|
CHONGCHONG_ADMIN_USERNAME: 'admin', CHONGCHONG_ADMIN_PASSWORD: 'test-only', ADMIN_PDA_USERNAME: 'pda', ADMIN_PDA_PASSWORD: 'test-only' }
|
|
const args = ['--execute','--environment=TEST',`--run-id=${runId}`,'--fixture=NEW']
|
|
const execArgs = [`--env-file=${resolve('/.codex/env/chongchong-global/test-acceptance.env')}`]
|
|
assert.equal(executionOptions(args, execArgs, env, cwd).fixture, 'NEW')
|
|
assert.equal(executionOptions(args, execArgs, env, cwd).gateway, 'https://test.invalid')
|
|
assert.throws(() => executionOptions(args, execArgs, { ...env, CHONGCHONG_ADMIN_API_BASE_URL: 'https://test.invalid' }, cwd), /end in/)
|
|
})
|
|
|
|
test('nested generated customer passwords and login/refresh tokens never reach saved evidence', () => {
|
|
const value = redact({ requests: [{ response: { data: { temporaryPassword: 'SECRET', nested: { accessToken: 'TOKEN', refreshToken: 'REFRESH' }, tenantId: '11' } } }] })
|
|
const json = JSON.stringify(value)
|
|
assert.ok(!json.includes('SECRET') && !json.includes('TOKEN') && !json.includes('REFRESH'))
|
|
assert.ok(json.includes('"tenantId":"11"'))
|
|
})
|
|
|
|
test('real HTTP multipart adapter preserves descriptor bytes, existing form fields and generated boundary', async () => {
|
|
const received = [], original = Uint8Array.from([137,80,78,71,13,10,26,10,0,255,10,13,0,200])
|
|
const server = createServer(async (request, response) => {
|
|
const chunks = []; for await (const chunk of request) chunks.push(chunk)
|
|
received.push({ headers: request.headers, body: Buffer.concat(chunks), method: request.method })
|
|
response.writeHead(200, { 'Content-Type': 'application/json' }); response.end('{"code":"200"}')
|
|
})
|
|
await new Promise(done => server.listen(0, '127.0.0.1', done))
|
|
try {
|
|
const base = `http://127.0.0.1:${server.address().port}`
|
|
const adapter = multipartAdapter((method, path, body, role, headers) => {
|
|
assert.equal(role, 'admin'); return fetch(base + path, requestInit(method, body, 'test-token', headers))
|
|
}, () => 'admin')
|
|
await adapter('POST', '/upload', { content: original, type: 'image/png', name: 'weight.png' }, 'token')
|
|
const form = new FormData(); form.append('expectedVersion', '4'); form.append('file', new Blob([original], { type: 'image/png' }), 'original.png')
|
|
await adapter('POST', '/upload', form, 'token', { 'Content-Type': 'application/json', 'Idempotency-Key': 'same-key' })
|
|
assert.equal(received.length, 2)
|
|
for (const request of received) {
|
|
assert.match(request.headers['content-type'], /^multipart\/form-data; boundary=/)
|
|
const boundary = request.headers['content-type'].split('boundary=')[1]
|
|
assert.ok(request.body.subarray(0, boundary.length + 2).equals(Buffer.from(`--${boundary}`)))
|
|
assert.ok(request.body.includes(Buffer.from(original)), 'The original byte array reaches HTTP without JSON conversion')
|
|
assert.ok(request.body.includes(Buffer.from('name="file"')))
|
|
assert.ok(!request.body.includes(Buffer.from('name="content"')))
|
|
assert.equal(request.method, 'POST')
|
|
}
|
|
assert.ok(received[1].body.includes(Buffer.from('name="expectedVersion"\r\n\r\n4')))
|
|
assert.equal(received[1].headers['idempotency-key'], 'same-key')
|
|
} finally { server.closeAllConnections(); await new Promise(done => server.close(done)) }
|
|
})
|
|
|
|
test('explicit resume proves the original failed sample and refuses state/identity drift before writes', () => {
|
|
const summary = { id: '2106706513799155714', tenantId: '2106706477225971713', orderId: '2106706495895306242',
|
|
orderNo: 'FL2106706495895306242', inboundCode: 'NYEXX2610040025', processStatus: 'WAIT_MEASURE', version: 4 }
|
|
const measurement = { measurementId: '2106706548955811842', measurementStatus: 'DRAFT', version: 4, weightResults: [] }
|
|
const readback = { verified: true, sessionClosed: true, inbound: { summary }, measurement }
|
|
const report = { runId: 'PARTIAL-ACTUAL-20261004-r1', success: false, cases: [], requests: [{ path: '/api/platform/v1/files/measurements/2106706477225971713/2106706513799155714', http: 200, code: 'S0500', requestId: 'original-id' }] }
|
|
const owner = validateResumeProof(report, readback)
|
|
validateResumeLive(owner, readback, readback.inbound, measurement)
|
|
assert.throws(() => validateResumeProof({ ...report, runId: 'unrelated' }, readback), /explicitly authorized/)
|
|
assert.throws(() => validateResumeLive(owner, readback, { summary: { ...summary, version: 5 } }, measurement), /changed/)
|
|
assert.throws(() => validateResumeLive(owner, readback, readback.inbound, { ...measurement, weightResults: [{ id: '1' }] }), /changed/)
|
|
assert.throws(() => validateResumeProof(report, { ...readback, measurement: { ...measurement, measurementStatus: 'APPROVED' } }), /Frozen/)
|
|
})
|
|
|
|
test('original draft resumes by upload/measurement only, with independent 3+1 SKU rows', async () => {
|
|
const owner = { tenantId: '11', inboundId: '12', orderId: '13', marker: 'ORIGINAL' }
|
|
const initial = { measurementId: '14', version: 5, latestDeclaration: { items: [
|
|
{ inboundDetailId: '21', itemNo: 1, cargoName: 'SKU1', packageCount: 3, lengthCm: 30, widthCm: 20, heightCm: 20 },
|
|
{ inboundDetailId: '22', itemNo: 2, cargoName: 'SKU2', packageCount: 1, lengthCm: 40, widthCm: 30, heightCm: 30 }] } }
|
|
const calls = []; let approved = false
|
|
const context = { token: 'own-token', createdResources: {}, request: async (method, path, body) => {
|
|
calls.push({ method, path, body }); let data
|
|
if (path.includes('/files/measurements/')) data = { fileId: '41' }
|
|
else if (path.includes('/measurement/draft?')) data = { measurementId: '14' }
|
|
else if (path.includes('/weight-pallet-options?')) data = { records: [{ palletId: '51', palletCode: 'YW-TP-002' }] }
|
|
else if (path.includes('/weight-results/61/confirm?')) data = { recognitionStatus: 'CONFIRMED' }
|
|
else if (path.includes('/weight-results?')) data = { id: '61', version: 0 }
|
|
else if (path.includes('/measurement/submit?')) data = { processStatus: 'MEASURE_PENDING' }
|
|
else if (path.includes('/measurements/approve?')) { approved = true; data = {} }
|
|
else if (path.includes('/measurement?')) data = { measurementId: '14', version: 6, measurementStatus: approved ? 'APPROVED' : 'DRAFT',
|
|
processStatus: approved ? 'WAIT_SPLIT' : 'WAIT_MEASURE', items: initial.latestDeclaration.items }
|
|
else if (path.startsWith('/api/platform/inbounds/')) data = { summary: { version: 7 } }
|
|
else throw Error('Unexpected original-recovery endpoint')
|
|
return { path, http: 200, body: { code: '200', data } }
|
|
} }
|
|
context.requestMultipart = multipartAdapter(context.request, () => 'admin')
|
|
await resumeMeasurementDraft(context, owner, initial)
|
|
assert.equal(context.createdResources.inboundMeasurement.inboundId, '12')
|
|
assert.equal(context.createdResources.inboundMeasurement.processStatus, 'WAIT_SPLIT')
|
|
assert.ok(calls[0].body instanceof FormData)
|
|
assert.deepEqual(calls.find(call => call.path.includes('/measurement/draft?')).body.items.map(item => [item.inboundDetailId, item.packageCount]), [['21',3],['22',1]])
|
|
assert.ok(!calls.some(call => /carton-scans|\/iam\/tenants|\/orders/.test(call.path)), 'No qualification, creation, order submission or re-scan')
|
|
})
|
|
|
|
test('zero-work checkpoint accepts own preassignment but rejects another operator or any physical pick', () => {
|
|
const { source, task } = fixture()
|
|
task.taskStatus = 'LOADING'; task.workflowStatus = 'IN_PROGRESS'; task.assignment = { assigneeId: '99' }
|
|
source.beforeTaskVersion = 0
|
|
validateZeroWorkTask(source, task, '99')
|
|
assert.throws(() => validateZeroWorkTask(source, task, '98'), /own PDA/)
|
|
task.items[0].pickedPackageCount = 1
|
|
assert.throws(() => validateZeroWorkTask(source, task, '99'), /physical work/)
|
|
})
|
|
|
|
test('prepared continuation binds the two original-source checkpoints and refuses to redo PDA writes', () => {
|
|
const report = { runId: 'PARTIAL-ACTUAL-20261004-recovery-r3', success: false, cases: [], requests: [],
|
|
recovery: { originalOwner: { inboundId: '2106706513799155714' }, originalSha256: 'frozen-original-hash' },
|
|
preparation: ['A','B'].map(kind => ({ kind, stage: 'PDA_UNASSIGNED', source: { sourceMarker: `PARTIAL-ACTUAL-20261004-recovery-r3-${kind}` }, spec: { kind } })) }
|
|
assert.equal(validatePreparedResume(report).length, 2)
|
|
assert.throws(() => validatePreparedResume({ ...report, requests: [{ method: 'POST', path: '/api/platform/v1/first-leg/pda-loading/tasks/91/batch' }] }), /repeat any PDA/)
|
|
assert.throws(() => validatePreparedResume({ ...report, cases: [{ completed: true }] }), /Only this/)
|
|
})
|
|
|
|
test('A recovery takes only the original command id and immutable version/operation/remark', () => {
|
|
const body = { expectedTaskVersion: 2, operationId: 'PARTIAL-ACTUAL-20261004-recovery-r3-A-complete', remark: 'PARTIAL-ACTUAL-20261004-recovery-r3-A' }
|
|
const report = { runId: 'PARTIAL-ACTUAL-20261004-recovery-r7', success: false, requests: [{ method: 'POST',
|
|
path: '/api/platform/v1/first-leg/pda-loading/tasks/2106713892758491138/complete', state: 'RECEIVED', http: 200, code: '200', request: body,
|
|
response: { data: { completionCommand: { id: '2106716718935052290', operationId: body.operationId, expectedTaskVersion: 2 } } } }] }
|
|
assert.deepEqual(originalCompletionCommand(report), { commandId: '2106716718935052290', body })
|
|
const changed = structuredClone(report); changed.requests[0].request.expectedTaskVersion = 4
|
|
assert.throws(() => originalCompletionCommand(changed), /immutable/)
|
|
const duplicated = structuredClone(report); duplicated.requests.push(duplicated.requests[0])
|
|
assert.throws(() => originalCompletionCommand(duplicated), /Exactly one/)
|
|
})
|
|
|
|
test('physical A facts exclude skipped rows and unchanged owners/stock detect a repeated completion or deduction', () => {
|
|
const sample = fixture('A')
|
|
sample.task.items = sample.task.items.map(row => ({ ...row, itemStatus: { PARTIAL: 'PARTIAL', PICK: 'PICKED', SKIP: 'SKIPPED' }[sample.expected.find(item => item.pickId === row.id).action],
|
|
pickedPackageCount: sample.expected.find(item => item.pickId === row.id).actual }))
|
|
verifyPhysicalFacts(sample.expected, sample.task)
|
|
const drift = structuredClone(sample.task); drift.items[0].pickedPackageCount++
|
|
assert.throws(() => verifyPhysicalFacts(sample.expected, drift), /drift/)
|
|
const before = { sources: [{ owner: { inboundId: '1' }, view: { summary: { id: '1', processStatus: 'LOADED', version: 12 }, statusHistory: [{ action: 'COMPLETE_LOADING' }], palletLocations: [] } }], inventory: { inbounds: [] } }
|
|
verifyOldOwnersUnchanged(before, structuredClone(before), sample.expected)
|
|
const repeated = structuredClone(before); repeated.sources[0].view.statusHistory.push({ action: 'COMPLETE_LOADING' })
|
|
assert.throws(() => verifyOldOwnersUnchanged(before, repeated, sample.expected), /must not repeat/)
|
|
const deducted = structuredClone(before); deducted.inventory.inbounds.push({ availablePackageCount: 1 })
|
|
assert.throws(() => verifyOldOwnersUnchanged(before, deducted, sample.expected), /deducted again/)
|
|
})
|
|
|
|
test('transit evidence uses raw balance identity and excludes transit from physical total, with no skipped source or duplicate ledger', () => {
|
|
const sample = fixture('A'); sample.source.containerNo = 'TEST-CONTAINER'
|
|
for (const row of sample.expected) { row.frozen.inboundCode = `IN-${row.inboundId}`; row.frozen.skuCode = `SKU-${row.itemId}` }
|
|
const snapshot = ['1','3','4'].map(inboundId => {
|
|
const active = sample.expected.filter(row => row.inboundId === inboundId && row.actual > 0), ownerRow = sample.expected.find(row => row.inboundId === inboundId)
|
|
const owner = { inboundId, tenantId: ownerRow.accountId }, count = active.reduce((sum,row) => sum + row.actual, 0)
|
|
if (!count) return { owner, orders: [], balances: [], ledger: [], details: [] }
|
|
const order = { id: `100${inboundId}`, orderNo: `LL-${inboundId}`, customerId: owner.tenantId, sourceInboundId: inboundId,
|
|
sourceContainerBookingId: sample.source.containerBookingId, containerNo: sample.source.containerNo, packageCount: count }
|
|
return { owner, orders: [order], details: [{ cargo: active.map(row => ({ skuCode: row.frozen.skuCode, packageCount: row.actual })),
|
|
statusHistory: [{ toStatus: 'PENDING_ASSIGNMENT', remark: '头程装柜完成自动生成' }] }],
|
|
balances: [{ customerId: owner.tenantId, inboundCode: `IN-${inboundId}`, inboundOrderId: order.id, inTransitPackages: count,
|
|
totalPackages: 0, availablePackages: 0, holdPackages: 0, allocatedPackages: 0, pickedPackages: 0, receivingPackages: 0, procurementPackages: 0 }],
|
|
ledger: [{ customerId: owner.tenantId, inboundCode: `IN-${inboundId}`, inboundOrderId: order.id, businessOrderNo: order.orderNo,
|
|
beforePackages: 0, deltaPackages: count, afterPackages: count }] }
|
|
})
|
|
assert.equal(verifyDownstream(sample, snapshot).actualPackages, 3)
|
|
const doubled = structuredClone(snapshot); doubled[0].ledger.push(doubled[0].ledger[0])
|
|
assert.throws(() => verifyDownstream(sample, doubled), /inventory movement/)
|
|
const grouped = structuredClone(snapshot); grouped[0].balances[0].inboundOrderId = null
|
|
assert.throws(() => verifyDownstream(sample, grouped), /transit inventory/)
|
|
const skipped = structuredClone(snapshot); skipped[2].orders.push(snapshot[0].orders[0])
|
|
assert.throws(() => verifyDownstream(sample, skipped), /Skipped owner/)
|
|
})
|
|
|
|
test('manifest needs two ordered cases, unique actions and all five photos', () => {
|
|
const manifest = { schemaVersion: 1, runId, environment: 'TEST', cases: [fixture('A').spec, fixture('B').spec] }
|
|
assert.equal(validateManifest(manifest, runId), manifest)
|
|
const duplicate = structuredClone(manifest); duplicate.cases[1].actions[1].itemId = '1'
|
|
assert.throws(() => validateManifest(duplicate, runId), /unique/)
|
|
const missing = structuredClone(manifest); delete missing.cases[0].evidence.SEAL
|
|
assert.throws(() => validateManifest(missing, runId), /Five/)
|
|
})
|
|
|
|
test('official source must be fresh, passing, unclaimed and run-bound', () => {
|
|
const now = Date.parse('2026-10-04T12:00:00Z'), report = { success: true, fatal: null, summary: { failed: 0 }, gateway: 'https://test.invalid',
|
|
createdResources: { manualPdaBatchFixture: { ...fixture().source, schemaVersion: 1, stage: 'MANUAL_PDA_CLAIM_AND_BATCH_READY',
|
|
preparedAt: new Date(now).toISOString(), taskItems: fixture().task.items } } }
|
|
assert.ok(fixtureSource(report, runId, report.gateway, now))
|
|
assert.throws(() => fixtureSource(report, runId, report.gateway, now + 25 * 3600_000), /within/)
|
|
const old = structuredClone(report); old.createdResources.manualPdaBatchFixture.sourceMarker = 'old'
|
|
assert.throws(() => fixtureSource(old, runId, report.gateway, now), /run-bound/)
|
|
const failed = structuredClone(report); failed.summary.failed = 1
|
|
assert.throws(() => fixtureSource(failed, runId, report.gateway, now), /did not pass/)
|
|
})
|
|
|
|
test('exact HALF_UP handles non-half ratios, ties, nullable metrics and invalid ratios', () => {
|
|
assert.equal(scale('10.001', 2, 3, 3), '6.667')
|
|
assert.equal(scale('8.002', 2, 3, 3), '5.335')
|
|
assert.equal(scale('0.1001', 2, 3, 4), '0.0667')
|
|
assert.equal(scale('1', 1, 2, 0), '1')
|
|
assert.equal(scale(null, 1, 2, 3), null)
|
|
assert.throws(() => scale('10', 4, 3, 3))
|
|
})
|
|
|
|
test('A and B require the exact actual/skip shapes before any mutation', () => {
|
|
assert.equal(fixture('A').expected.filter(row => row.actual > 0).length, 2)
|
|
assert.ok(fixture('B').expected.filter(row => row.actual > 0).every(row => row.action === 'PARTIAL'))
|
|
const { spec, task, preload } = fixture('B')
|
|
spec.actions[0] = { itemId: '1', action: 'PICK' }
|
|
assert.throws(() => expectedRows(spec, task, preload), /exactly one/)
|
|
spec.actions[0] = { itemId: '1', action: 'PARTIAL', finalPickedPackageCount: 2 }
|
|
assert.throws(() => expectedRows(spec, task, preload), /less than/)
|
|
})
|
|
|
|
test('duplicate, missing, already picked and wrong-customer source rows reject preflight', () => {
|
|
const a = fixture('A'); a.spec.actions.pop()
|
|
assert.throws(() => expectedRows(a.spec, a.task, a.preload), /cover every/)
|
|
const b = fixture(); b.task.items[0].pickedPackageCount = 1
|
|
assert.throws(() => expectedRows(b.spec, b.task, b.preload), /zero-picked/)
|
|
const c = fixture(); c.preload.items[0].accountId = '999'
|
|
assert.throws(() => expectedRows(c.spec, c.task, c.preload), /identity/)
|
|
})
|
|
|
|
test('actual scope, metrics and refund customer/coverage are independently checked', () => {
|
|
for (const kind of ['A', 'B']) {
|
|
const sample = fixture(kind)
|
|
assert.equal(verifyActual(sample.expected, sample.detail, sample.customs).actualRows, kind === 'A' ? 2 : 1)
|
|
const contaminated = structuredClone(sample.detail); contaminated.items.push(sample.preload.items.at(-1))
|
|
assert.throws(() => verifyActual(sample.expected, contaminated, sample.customs), /Actual loading row set/)
|
|
const stale = structuredClone(sample.customs); stale.actualBoxCount++
|
|
assert.throws(() => verifyActual(sample.expected, sample.detail, stale), /Customs actual boxes/)
|
|
const wrong = structuredClone(sample.customs); wrong.inbounds[0].accountId = '999'
|
|
assert.throws(() => verifyActual(sample.expected, sample.detail, wrong), /Customs source/)
|
|
}
|
|
})
|
|
|
|
function transport(sample, { drift = false, failCompletion = false, incomplete = false } = {}) {
|
|
const calls = [], task = structuredClone(sample.task), customs = structuredClone(sample.customs)
|
|
const history = [], pda = `/api/platform/v1/first-leg/pda-loading/tasks/${sample.source.pdaTaskId}`
|
|
let completes = 0
|
|
return { calls, request: async (method, path, body, role, headers) => {
|
|
calls.push({ method, path, body: body instanceof FormData ? 'multipart' : structuredClone(body), role, headers })
|
|
let data
|
|
if (method === 'POST' && path === `${pda}/claim`) { task.workflowStatus = 'IN_PROGRESS'; data = task }
|
|
else if (method === 'POST' && /\/items\/\d+\/skip$/.test(path)) {
|
|
const itemId = path.split('/').at(-2)
|
|
task.items = task.items.map(row => row.id === itemId ? { ...row, itemStatus: 'SKIPPED', pickedPackageCount: 0 } : row)
|
|
data = task
|
|
}
|
|
else if (method === 'POST' && path === `${pda}/batch`) {
|
|
task.workflowStatus = 'AWAITING_REVIEW'; task.items = task.items.map(row => {
|
|
const expected = sample.expected.find(item => item.pickId === row.id)
|
|
return { ...row, itemStatus: { PICK: 'PICKED', PARTIAL: 'PARTIAL', SKIP: 'SKIPPED' }[expected.action], pickedPackageCount: expected.actual }
|
|
}); data = task
|
|
} else if (method === 'POST' && path === `${pda}/evidence`) data = {}
|
|
else if (path.startsWith(`${pda}/evidence?`)) data = { evidences: Object.keys(evidence).map(type => ({ evidenceType: type, status: 'ACTIVE', sealNo: sample.spec.sealNo })) }
|
|
else if (method === 'POST' && path === `${pda}/complete`) {
|
|
completes++
|
|
if (failCompletion) throw Error('Response lost')
|
|
task.taskStatus = incomplete ? 'COMPLETING' : 'COMPLETED'; task.workflowStatus = incomplete ? 'COMPLETING' : 'COMPLETED'
|
|
if (completes === 1) history.push({ actionType: 'COMPLETE_LOADING' })
|
|
if (drift && completes > 1) task.version++
|
|
data = task
|
|
} else if (path.startsWith(`${pda}/inventory-snapshot?`)) data = { snapshotToken: 'fresh-snapshot' }
|
|
else if (path.startsWith(`${pda}?`)) data = task
|
|
else if (path === `${pda}/operations`) data = history
|
|
else if (path.includes('/loading-lists/')) data = sample.detail
|
|
else if (path.endsWith('/send-to-broker')) return { path, http: 200, body: { code: 'A0409' } }
|
|
else if (path.endsWith('/start')) { customs.status = 'DECLARING'; customs.version++; data = customs }
|
|
else if (path.endsWith('/complete-all-buy')) { customs.status = 'COMPLETED'; customs.version++; data = customs }
|
|
else if (path.includes('/customs/loading-plans/')) data = customs
|
|
else throw Error(`Unexpected ${method} ${path}`)
|
|
return { path, http: 200, body: { code: '200', data: structuredClone(data) } }
|
|
} }
|
|
}
|
|
|
|
test('both cases execute actual completion; B is all PARTIAL and follows all-buy gates', async () => {
|
|
for (const kind of ['A', 'B']) {
|
|
const sample = fixture(kind), http = transport(sample), images = Object.fromEntries(Object.keys(evidence).map(type => [type, { bytes: new Uint8Array([1,2,3]), type: 'image/png' }]))
|
|
const result = await runCase(sample.spec, sample.source, { ...sample, images }, http.request, async () => {})
|
|
assert.equal(result.completed, true); assert.equal(result.allActualRowsPartial, kind === 'B')
|
|
const completes = http.calls.filter(call => call.path.endsWith('/complete'))
|
|
assert.equal(completes.length, 2); assert.deepEqual(completes[0].body, completes[1].body)
|
|
const batches = http.calls.filter(call => call.path.endsWith('/batch'))
|
|
assert.equal(batches.length, 1)
|
|
if (kind === 'A') {
|
|
const skipIndex = http.calls.findIndex(call => /\/items\/\d+\/skip$/.test(call.path))
|
|
assert.ok(skipIndex >= 0 && skipIndex < http.calls.findIndex(call => call.path.endsWith('/batch')))
|
|
assert.ok(!batches[0].body.items.some(item => item.itemId === '2'), 'Resolved same-owner SKIP does not repeat in full pending batch')
|
|
}
|
|
if (kind === 'B') assert.ok(http.calls.some(call => call.path.endsWith('/complete-all-buy')))
|
|
}
|
|
})
|
|
|
|
test('replay version/history drift is a hard failure', async () => {
|
|
const sample = fixture(), http = transport(sample, { drift: true }), images = Object.fromEntries(Object.keys(evidence).map(type => [type, { bytes: new Uint8Array([1]), type: 'image/png' }]))
|
|
await assert.rejects(runCase(sample.spec, sample.source, { ...sample, images }, http.request), /zero projection/)
|
|
})
|
|
|
|
test('unknown completion result is never retried and no later customs write is attempted', async () => {
|
|
const sample = fixture(), http = transport(sample, { failCompletion: true }), images = Object.fromEntries(Object.keys(evidence).map(type => [type, { bytes: new Uint8Array([1]), type: 'image/png' }]))
|
|
await assert.rejects(runCase(sample.spec, sample.source, { ...sample, images }, http.request), /Response lost/)
|
|
assert.equal(http.calls.filter(call => call.path.endsWith('/complete')).length, 1)
|
|
assert.equal(http.calls.filter(call => call.method === 'POST' && call.path.includes('/customs/')).length, 0)
|
|
})
|
|
|
|
test('accepted completion without terminal state fails rather than claiming success', async () => {
|
|
const sample = fixture(), http = transport(sample, { incomplete: true }), images = Object.fromEntries(Object.keys(evidence).map(type => [type, { bytes: new Uint8Array([1]), type: 'image/png' }]))
|
|
await assert.rejects(runCase(sample.spec, sample.source, { ...sample, images }, http.request, async () => {}), /polling exhausted/)
|
|
})
|