758 lines
60 KiB
JavaScript
758 lines
60 KiB
JavaScript
import assert from 'node:assert/strict'
|
|
import { verifyFleetCrossCustomer } from './fleet-cross-customer-acceptance.mjs'
|
|
import { run as createQualifiedMerchant } from './merchant-qualification-fixture.mjs'
|
|
import { nativeRelabelCreateBody } from '../overseas-relabel-real-acceptance.mjs'
|
|
import { finishFleetTrip } from './fleet-trip-fulfillment.mjs'
|
|
|
|
const ROOT = '/api/platform/v1/last-leg', MODULE = 'dispatch-workflow-extensions'
|
|
const OPTIONS = { scenario: MODULE, deploymentBlocker: true }
|
|
const clone = value => structuredClone(value)
|
|
const id = value => String(value ?? '')
|
|
export const extensionMatrix = Object.freeze([
|
|
{ scenario: 'dual-destination', scope: 'Two fresh customers, two distinct real FBA destinations, one main/trip; automatic isolated execution documents and actual fee facts', readiness: 'READY' },
|
|
{ scenario: 'reviews', scope: 'Both rejection/resubmission rounds, zero-pick return and cargo/resource changes, stale/version/idempotency conflicts', readiness: 'READY' },
|
|
{ scenario: 'relabel', scope: 'Fresh three-box customer receipt, confirmed zero-scan cancellation, two applications sharing one pallet and native rearrangement', readiness: 'READY_FORMAL_THREE_BOX_RECEIPT' },
|
|
{ scenario: 'competition', scope: 'Two-request Admin/PDA replay race, occupied resources gates; first-execution race remains untested', readiness: 'READY_BOUNDED_REPLAY' },
|
|
{ scenario: 'bol', scope: 'Fresh same-destination cargo, empty/same/different formal appointment allocations and actual PDF conservation', readiness: 'READY_FORMAL_APPOINTMENTS' },
|
|
])
|
|
export function assertDualDestinationFixture(fixture) {
|
|
assert.equal(fixture.members?.length, 2)
|
|
assert.equal(new Set(fixture.members.map(row => id(row.customerId))).size, 2)
|
|
assert.equal(new Set(fixture.members.map(row => row.destination?.key)).size, 2)
|
|
assert(fixture.members.every(row => row.destination?.key && row.receiptVerified === true))
|
|
assert(fixture.tripProof?.stops?.length >= 3)
|
|
for (const member of fixture.members)
|
|
assert(fixture.tripProof.stops.some(stop => stop.destinationKey === member.destination.key))
|
|
}
|
|
export function feeCents(value) {
|
|
assert(['string', 'number'].includes(typeof value) && /^(0|[1-9]\d*)(\.\d{1,2})?$/.test(String(value)), 'Non-canonical fee amount')
|
|
const [whole, fraction = ''] = String(value).split('.')
|
|
const cents = Number(whole) * 100 + Number(fraction.padEnd(2, '0'))
|
|
assert(Number.isSafeInteger(cents)); return cents
|
|
}
|
|
/** Public master-data reads only; no fixture writes until both independent US FBA masters are verified. */
|
|
export async function discoverSecondDestination(context, primaryId) {
|
|
const get = async path => {
|
|
const response = await context.request('GET', path)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200'); return response.body.data
|
|
}
|
|
const primary = await get(`/api/platform/v1/warehouse-admin/${encodeURIComponent(primaryId)}?tenantId=0`)
|
|
const country = primary.addresses?.find(row => row.addressLine1)?.countryCode
|
|
assert(country && primary.warehouse?.warehouseType === 'FBA' && primary.warehouse.status === 'ACTIVE')
|
|
let total, scanned = 0
|
|
const seen = new Set()
|
|
for (let page = 1; page <= 100; page++) {
|
|
const data = await get(`/api/platform/v1/warehouse-admin?${new URLSearchParams({ tenantId: '0', page: String(page), size: '200', warehouseType: 'FBA', status: 'ACTIVE', countryCode: country })}`)
|
|
assert(Array.isArray(data.records)); assert.equal(Number(data.page), page); assert.equal(Number(data.size), 200)
|
|
assert(Number.isSafeInteger(Number(data.total)) && Number(data.total) >= 0)
|
|
total ??= Number(data.total); assert.equal(Number(data.total), total)
|
|
assert(data.records.length > 0 || scanned === total)
|
|
for (const row of data.records) {
|
|
assert(row.id && !seen.has(id(row.id))); seen.add(id(row.id)); scanned++
|
|
if (id(row.id) === id(primaryId)) continue
|
|
const candidate = await get(`/api/platform/v1/warehouse-admin/${encodeURIComponent(row.id)}?tenantId=0`)
|
|
if (candidate.warehouse?.warehouseType !== 'FBA' || candidate.warehouse.status !== 'ACTIVE'
|
|
|| id(candidate.warehouse.tenantId) !== '0' || candidate.warehouse.warehouseCode === primary.warehouse.warehouseCode) continue
|
|
if (candidate.addresses?.some(address => address.addressLine1 && address.countryCode === country)) return id(row.id)
|
|
}
|
|
if (scanned === total) break
|
|
}
|
|
throw Error('No second distinct public active FBA destination with a real same-country address; no fixture created')
|
|
}
|
|
|
|
/** Reuse the formal full-chain verifier; only explicitly supplied synthetic fee amounts differ by customer. */
|
|
export async function verifyDualDestination(context, fixture, options) {
|
|
if (!options.bol) assertDualDestinationFixture(fixture)
|
|
else {
|
|
assert.equal(fixture.members.length, 2); assert.equal(new Set(fixture.members.map(row => row.customerId)).size, 2)
|
|
assert.equal(new Set(fixture.members.map(row => row.destination.key)).size, 1)
|
|
assert(fixture.members.every(row => row.receiptVerified === true))
|
|
}
|
|
const proof = context.createdResources.dispatchWorkflowExtensions = { scenario: options.bol || 'dual-destination', marker: context.marker,
|
|
dispatchNo: fixture.dispatchNo, status: 'CHECKING', syntheticTestMaterials: true, physicalMeasurementVerified: false,
|
|
hardwareVerified: false, midTransactionRollback: 'NOT_TESTED_NO_CONTROLLED_INJECTION', isolation: [] }
|
|
const original = context.request
|
|
let deferredFailure, raceDone = false, firstRaceDone = false
|
|
const mainPath = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
|
|
const pdaPath = `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
|
|
context.request = async function (method, path, body, ...rest) {
|
|
if (deferredFailure) throw deferredFailure
|
|
let response
|
|
if (options.firstCompetition && !firstRaceDone && method === 'POST' && path === `${pdaPath}/loading-complete`
|
|
&& fixture.tripProof.loadingCommand?.body?.idempotencyKey === body?.idempotencyKey) {
|
|
firstRaceDone = true
|
|
const outcome = await executeFirstLoadingRace(context, fixture, options, original.bind(this), body)
|
|
response = outcome.pdaResponse
|
|
if (outcome.error) deferredFailure = outcome.error
|
|
} else response = await original.call(this, method, path, body, ...rest)
|
|
// 写请求已收到确定回执后，只做独立扩展；后续核验失败延至下一读请求抛出，不能把已知成功伪报成未知写。
|
|
if (!deferredFailure && response.http === 200 && String(response.body?.code) === '200') {
|
|
try {
|
|
if (options.competition && method === 'POST' && path === `${pdaPath}/loading-complete` && !raceDone
|
|
&& response.body.data?.replayed !== true && response.body.data?.stage === 'DELIVERING') {
|
|
raceDone = true
|
|
await verifyLoadingReplayRace(context, fixture, options, original.bind(this), body, response.body.data)
|
|
}
|
|
if (method === 'PUT' && body?.idempotencyKey === `${context.marker}-CROSS-SIGN-1`) {
|
|
const fence = proof.completionReadFence = { status: 'READING', attempts: [], writeReceiptPreserved: true }
|
|
for (let attempt = 1; attempt <= 60; attempt++) {
|
|
const current = await original.call(this, 'GET', mainPath)
|
|
assert.equal(current.http, 200); assert.equal(String(current.body?.code), '200')
|
|
assert.equal(current.body.data?.dispatchNo, fixture.dispatchNo)
|
|
fence.attempts.push({ attempt, stage: current.body.data.stage, recordVersion: current.body.data.recordVersion,
|
|
requestId: current.requestId, traceId: current.traceId })
|
|
if (current.body.data.stage === 'DELIVERED') { fence.status = 'DELIVERED'; break }
|
|
assert.equal(current.body.data.stage, 'DELIVERING')
|
|
await context.checkpoint(); await new Promise(resolve => setTimeout(resolve, 500))
|
|
}
|
|
assert.equal(fence.status, 'DELIVERED', 'Automatic completion did not settle within 30 seconds')
|
|
await context.checkpoint()
|
|
}
|
|
} catch (error) { deferredFailure = error }
|
|
}
|
|
return response
|
|
}
|
|
let verified
|
|
try { verified = await verifyFleetCrossCustomer(context, fixture, options) }
|
|
finally { context.request = original }
|
|
assert.equal(verified.status, 'VERIFIED')
|
|
const final = verified.snapshots.FINAL
|
|
assert.equal(new Set(final.dispatch.documents.deliveries.map(row => row.deliveryNo)).size, 2)
|
|
assert.equal(new Set(final.dispatch.documents.outbounds.map(row => row.outboundNo)).size, 2)
|
|
const feeIds = new Set()
|
|
for (const [index, member] of fixture.members.entries()) {
|
|
const delivery = final.members[index].delivery
|
|
assert.equal(id(delivery.order.customerId), member.customerId)
|
|
assert.equal(delivery.order.destinationWarehouseCode, member.destination.warehouseCode)
|
|
assert.equal(Number(delivery.order.packageCount), 1); assert.equal(Number(delivery.order.palletCount), 1)
|
|
assert(Array.isArray(delivery.fees))
|
|
for (const fee of delivery.fees) {
|
|
assert(fee.id && !feeIds.has(id(fee.id))); feeIds.add(id(fee.id))
|
|
assert.equal(fee.feeDirection, 'RECEIVABLE'); assert.equal(fee.sourceStatus, 'ACTIVE')
|
|
}
|
|
const other = fixture.members[1 - index]
|
|
const path = `${ROOT}/delivery-orders/${encodeURIComponent(delivery.order.deliveryNo)}?customerId=${encodeURIComponent(other.customerId)}`
|
|
const response = await context.request('GET', path)
|
|
const denied = [200, 403, 404].includes(response.http) && ['A0403', 'A0404'].includes(String(response.body?.code))
|
|
context.assert(MODULE, 'Foreign customer cannot read this delivery or its independent fees', response, denied, '', OPTIONS)
|
|
assert(denied)
|
|
proof.isolation.push({ customerId: member.customerId, wrongCustomerId: other.customerId, deliveryNo: delivery.order.deliveryNo,
|
|
http: response.http, code: response.body.code, requestId: response.requestId, traceId: response.traceId })
|
|
}
|
|
proof.status = 'VERIFIED'; await context.checkpoint(); return verified
|
|
}
|
|
|
|
const receipt = response => ({ http: response.http, code: response.body?.code, message: response.body?.message,
|
|
requestId: response.requestId, traceId: response.traceId })
|
|
async function competitionSnapshot(context, fixture, { readInventory }, send) {
|
|
const path = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
|
|
const state = {}
|
|
for (const [name, target] of [['main', path], ['items', `${path}/items`], ['loading', `${path}/loading`],
|
|
['trip', `${ROOT}/fleet/trips/${encodeURIComponent(fixture.tripNo)}`]]) {
|
|
const response = await send('GET', target)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200'); state[name] = response.body.data
|
|
}
|
|
state.stock = []
|
|
for (const member of fixture.members) state.stock.push(await readInventory({ marker: context.marker,
|
|
customerId: member.customerId, warehouseId: fixture.warehouseId }))
|
|
return state
|
|
}
|
|
|
|
/** 仅两个请求同时发送；使用已成功装车的原键，明确区别首次执行竞争。 */
|
|
export async function verifyLoadingReplayRace(context, fixture, options, send, body, acknowledged) {
|
|
const proof = context.createdResources.dispatchWorkflowCompetition
|
|
assert(proof && proof.status === 'CHECKING')
|
|
const path = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}/loading-complete`
|
|
const pda = `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}/loading-complete`
|
|
const race = proof.loadingReplayRace = { status: 'INTENT', scope: 'ACKNOWLEDGED_COMMAND_TWO_ACTOR_REPLAY',
|
|
firstExecutionRace: 'NOT_TESTED', body: clone(body), before: await competitionSnapshot(context, fixture, options, send) }
|
|
await context.checkpoint()
|
|
const results = await Promise.allSettled([send('POST', pda, clone(body), fixture.pdaToken), send('POST', path, clone(body))])
|
|
race.responses = results.map(result => result.status === 'fulfilled' ? receipt(result.value) : { outcome: 'UNKNOWN_RESULT' })
|
|
race.status = results.every(result => result.status === 'fulfilled') ? 'RESPONDED' : 'UNKNOWN_RESULT'
|
|
await context.checkpoint()
|
|
for (const result of results) if (result.status === 'rejected') throw result.reason
|
|
const [pdaResult, adminResult] = results.map(result => result.value)
|
|
assert.equal(String(pdaResult.body?.code), '200'); assert.equal(pdaResult.body?.data?.replayed, true)
|
|
assert.deepEqual(pdaResult.body.data.result, acknowledged.result)
|
|
assert.equal(id(pdaResult.body.data.recordVersion), id(acknowledged.recordVersion))
|
|
assert.equal(String(adminResult.body?.code), 'A0403'); assert.match(adminResult.body?.message || '', /操作员/)
|
|
race.after = await competitionSnapshot(context, fixture, options, send)
|
|
assert.deepEqual(race.after, race.before)
|
|
context.assert(MODULE, 'Concurrent Admin/PDA original-key replays preserve the one loading result and complete inventories',
|
|
pdaResult, true, '', OPTIONS)
|
|
race.status = 'VERIFIED'; await context.checkpoint()
|
|
}
|
|
|
|
/** 首次命令使用两个不同键和同一真实版本；胜者必须唯一，真实PDA回执原样交还调用者。 */
|
|
export async function executeFirstLoadingRace(context, fixture, options, send, body) {
|
|
const proof = context.createdResources.dispatchWorkflowCompetition
|
|
assert(proof && proof.status === 'CHECKING')
|
|
const adminBody = { ...clone(body), idempotencyKey: `${context.marker}-EXT-FIRST-ADMIN-LOAD` }
|
|
const race = proof.firstLoadingRace = { status: 'INTENT', pdaBody: clone(body), adminBody,
|
|
before: await competitionSnapshot(context, fixture, options, send) }
|
|
assert.equal(race.before.main.stage, 'LOADING'); assert.equal(Number(race.before.main.counts.pickedPackageCount), 2)
|
|
assert.equal(id(race.before.main.recordVersion), id(body.recordVersion)); await context.checkpoint()
|
|
const results = await Promise.allSettled([
|
|
send('POST', `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}/loading-complete`, clone(body), fixture.pdaToken),
|
|
send('POST', `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}/loading-complete`, adminBody),
|
|
])
|
|
race.responses = results.map(result => result.status === 'fulfilled' ? receipt(result.value) : { outcome: 'UNKNOWN_RESULT' })
|
|
race.status = results.every(result => result.status === 'fulfilled') ? 'RESPONDED' : 'UNKNOWN_RESULT'; await context.checkpoint()
|
|
for (const result of results) if (result.status === 'rejected') throw result.reason
|
|
const responses = results.map(result => result.value)
|
|
try {
|
|
const winnerIndexes = responses.map((response, index) => String(response.body?.code) === '200' ? index : -1).filter(index => index >= 0)
|
|
assert.equal(winnerIndexes.length, 1)
|
|
const winnerIndex = winnerIndexes[0], winner = responses[winnerIndex], loser = responses[1 - winnerIndex]
|
|
assert.equal(String(loser.body?.code), 'A0409')
|
|
assert.equal(winner.body.data.stage, 'DELIVERING')
|
|
assert.equal(winner.body.data.result?.confirmedLoad?.manifestHash, body.manifestHash)
|
|
assert(BigInt(winner.body.data.recordVersion) > BigInt(body.recordVersion))
|
|
race.after = await competitionSnapshot(context, fixture, options, send)
|
|
assert.equal(race.after.main.stage, 'DELIVERING')
|
|
assert.equal(id(race.after.main.recordVersion), id(winner.body.data.recordVersion))
|
|
assert.deepEqual(race.after.stock, race.before.stock)
|
|
assert.equal(Number(race.after.main.counts.packageCount), 2)
|
|
assert.equal(Number(race.after.main.counts.pickedPackageCount), 2)
|
|
race.winner = winnerIndex === 0 ? 'PDA' : 'ADMIN'; race.winnerResult = clone(winner.body.data)
|
|
race.status = 'VERIFIED'; proof.firstExecutionRace = 'VERIFIED'
|
|
context.assert(MODULE, 'First valid Admin/PDA loading race commits exactly one version and preserves complete inventories', winner, true, '', OPTIONS)
|
|
await context.checkpoint()
|
|
if (winnerIndex !== 0) return { pdaResponse: responses[0], error: Error('Admin won the first loading race; original PDA rejection retained, no fulfillment replay') }
|
|
return { pdaResponse: responses[0] }
|
|
} catch (error) {
|
|
race.verificationError = error.message; await context.checkpoint()
|
|
return { pdaResponse: responses[0], error }
|
|
}
|
|
}
|
|
|
|
export async function verifyCompetitionExtension(context, fixture, options) {
|
|
const proof = context.createdResources.dispatchWorkflowCompetition = { marker: context.marker, dispatchNo: fixture.dispatchNo,
|
|
status: 'CHECKING', firstExecutionRace: 'NOT_TESTED', arbitraryPrivilegeMatrix: 'NOT_TESTED_NO_PERMISSION_MUTATION' }
|
|
const before = await competitionSnapshot(context, fixture, options, context.request.bind(context))
|
|
const body = { idempotencyKey: `${context.marker}-EXT-OCCUPIED-RESOURCE`, warehouseId: fixture.warehouseId,
|
|
vehicle: { mode: 'MASTER', vehicleId: fixture.tripProof.vehicleId },
|
|
driver: { mode: 'MASTER', driverId: fixture.tripProof.driverId, evidence: { expectedTaskEndAt: fixture.tripProof.expectedDriverEndAt } },
|
|
plannedDepartureAt: new Date(Date.now() + 3600000).toISOString(), estimatedArrivalAt: null,
|
|
remark: `${context.marker} TEST已占用资源不能分配另一空车`, cargo: [], batchAllocations: [] }
|
|
proof.resourceConflict = { status: 'INTENT', body: clone(body), before }; await context.checkpoint()
|
|
const response = await context.request('POST', `${ROOT}/dispatches`, body)
|
|
proof.resourceConflict.response = receipt(response); await context.checkpoint()
|
|
assert.equal(String(response.body?.code), 'A0409'); assert.match(response.body?.message || '', /车辆.*占用|司机.*占用/)
|
|
proof.resourceConflict.after = await competitionSnapshot(context, fixture, options, context.request.bind(context))
|
|
assert.deepEqual(proof.resourceConflict.after, before)
|
|
context.assert(MODULE, 'Occupied vehicle/driver reject a second native main without changing the existing trip or inventory', response, true, '', OPTIONS)
|
|
proof.resourceConflict.status = 'VERIFIED'
|
|
const verified = await verifyDualDestination(context, fixture, { ...options, competition: true })
|
|
assert.equal(proof.loadingReplayRace?.status, 'VERIFIED')
|
|
if (options.firstCompetition) assert.equal(proof.firstLoadingRace?.status, 'VERIFIED')
|
|
proof.status = options.firstCompetition ? 'VERIFIED_FIRST_EXECUTION_AND_REPLAY' : 'VERIFIED_BOUNDED_SCOPE'
|
|
await context.checkpoint(); return verified
|
|
}
|
|
|
|
export const verifyFirstCompetitionExtension = (context, fixture, options) => verifyCompetitionExtension(context, fixture, { ...options, firstCompetition: true })
|
|
|
|
/** 仅使用本轮PDA实收的一箱来源，正式创建预约并向原生建单返回实际份额。 */
|
|
export async function prepareBolAppointments(context, members, scenario, warehouseId) {
|
|
assert(['bol-empty', 'bol-same', 'bol-different'].includes(scenario))
|
|
const proof = context.createdResources.dispatchWorkflowBolAppointments = { scenario, status: 'PREPARING', appointments: [], allocations: [] }
|
|
if (scenario === 'bol-empty') { proof.status = 'NO_APPOINTMENT'; return [] }
|
|
const groups = scenario === 'bol-same' ? [members] : members.map(member => [member])
|
|
for (const [index, group] of groups.entries()) {
|
|
for (const member of group) {
|
|
const response = await context.request('GET', `${ROOT}/warehouse-transfers/${encodeURIComponent(member.incomingNo)}?customerId=${encodeURIComponent(member.customerId)}`)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200')
|
|
const transfer = response.body.data
|
|
assert.equal(transfer.transferNo, member.incomingNo); assert.equal(transfer.inboundCode, member.incomingNo)
|
|
assert.equal(id(transfer.inboundOrderId), id(member.receipt.balance.inboundOrderId))
|
|
assert.equal(id(transfer.operatingWarehouseId), warehouseId)
|
|
assert(transfer.lastlegOrderId && member.selection.planPalletId && member.receiptVerified)
|
|
member.appointmentSourceKey = `ORDER:${transfer.lastlegOrderId}`
|
|
}
|
|
const refs = group.map(member => {
|
|
return { customerId: member.customerId, sourceKey: member.appointmentSourceKey, destinationKey: member.destination.key }
|
|
})
|
|
const confirmationNo = `TEST-ISA-${context.marker.slice(-12)}-${index + 1}`
|
|
const body = { sources: refs, originWarehouseId: warehouseId, fbaWarehouseCode: group[0].destination.warehouseCode,
|
|
details: { appointmentStatus: 'SUCCESS', confirmationNo, appointmentAt: new Date(Date.now() + 48 * 3600000).toISOString().slice(0, 19),
|
|
appointmentEndAt: new Date(Date.now() + 50 * 3600000).toISOString().slice(0, 19), appointmentRemark: `${context.marker} TEST合成预约确认资料` },
|
|
idempotencyKey: `${context.marker}-BOL-AP-${index + 1}` }
|
|
const record = { status: 'INTENT', body: clone(body) }; proof.appointments.push(record); await context.checkpoint()
|
|
const response = await context.request('POST', `${ROOT}/appointment-planning/appointments`, body)
|
|
record.response = receipt(response); record.status = 'RESPONDED'; await context.checkpoint()
|
|
const data = context.apiSuccess(MODULE, 'Create own formal FBA appointment for exact received quantities', response, '', OPTIONS)
|
|
assert.equal(String(response.body?.code), '200'); assert(data?.batchKey && data.appointmentNo)
|
|
assert.equal(data.confirmationNo, confirmationNo); assert.equal(data.appointmentStatus, 'SUCCESS')
|
|
assert.equal(data.items.length, group.length); assert(Number.isSafeInteger(data.version) && data.version >= 0)
|
|
record.data = clone(data)
|
|
for (const member of group) {
|
|
const matches = data.items.filter(item => id(item.customerId) === member.customerId && item.sourceKey === member.appointmentSourceKey)
|
|
assert.equal(matches.length, 1); assert.equal(Number(matches[0].packageCount), 1)
|
|
assert.equal(matches[0].destinationKey, member.destination.key)
|
|
proof.allocations.push({ planPalletId: member.selection.planPalletId, batchKey: data.batchKey, customerId: member.customerId,
|
|
sourceKey: matches[0].sourceKey, destinationKey: matches[0].destinationKey, packageCount: 1, recordVersion: data.version })
|
|
}
|
|
record.status = 'VERIFIED'; await context.checkpoint()
|
|
}
|
|
proof.status = 'VERIFIED'; return clone(proof.allocations)
|
|
}
|
|
|
|
export function assertBolPages(pages, fixture, appointments, scenario) {
|
|
const expected = scenario === 'bol-different' ? 2 : 1
|
|
assert.equal(pages.length, expected)
|
|
const counts = [], isas = [], flattened = pages.map(page => page.replace(/\s/g, ''))
|
|
for (const page of pages) {
|
|
assert.match(page, /BILL OF LADING/)
|
|
const total = page.match(/Total\s+CTNS:\s*(\d+)/)
|
|
assert(total, 'Printed total box count missing'); counts.push(Number(total[1]))
|
|
const isaLine = page.split(/\r?\n/).find(line => line.includes('ISA #:'))
|
|
assert(isaLine !== undefined); isas.push(isaLine.split('ISA #:')[1].trim())
|
|
}
|
|
assert.equal(counts.reduce((sum, count) => sum + count, 0), 2)
|
|
// 现行窄托盘列会省略长托盘码；用完整入仓码核对原实收来源，每个来源在本夹具中严格对应一箱一实托。
|
|
for (const member of fixture.members) {
|
|
assert(member.incomingNo && member.palletNo)
|
|
assert.equal(flattened.reduce((sum, page) => sum + page.split(member.incomingNo).length - 1, 0), 1)
|
|
}
|
|
const expectedIsas = appointments.appointments.map(row => row.data.confirmationNo)
|
|
assert.deepEqual([...isas].sort(), scenario === 'bol-empty' ? [''] : [...expectedIsas].sort())
|
|
if (scenario !== 'bol-different') assert.deepEqual(counts, [2])
|
|
else assert.deepEqual(counts, [1, 1])
|
|
return { pageCount: pages.length, totalPackages: 2, packagesPerBol: counts, confirmationNos: isas,
|
|
eachSourcePrintedOnce: true, physicalPalletMapping: 'ONE_BOX_ONE_PALLET_PER_SOURCE', palletColumn: 'LONG_CODES_TRUNCATED_BY_EXISTING_TEMPLATE' }
|
|
}
|
|
|
|
export async function verifyBolExtension(context, fixture, options) {
|
|
assert(typeof options.inspectBol === 'function')
|
|
const proof = context.createdResources.dispatchWorkflowBol = { scenario: options.bol, status: 'CHECKING',
|
|
physicalMeasurementVerified: false, hardwareVerified: false }
|
|
proof.before = await competitionSnapshot(context, fixture, options, context.request.bind(context))
|
|
const pages = await options.inspectBol(context, fixture)
|
|
proof.printed = assertBolPages(pages, fixture, context.createdResources.dispatchWorkflowBolAppointments, options.bol)
|
|
proof.after = await competitionSnapshot(context, fixture, options, context.request.bind(context))
|
|
assert.deepEqual(proof.after, proof.before)
|
|
context.assert(MODULE, 'Actual BOL PDF preserves appointment shares, cross-customer grouping and complete inventory facts',
|
|
{ http: 200 }, true, '', OPTIONS)
|
|
proof.status = 'VERIFIED'; await context.checkpoint()
|
|
return verifyDualDestination(context, fixture, options)
|
|
}
|
|
|
|
/** Exercise edits only on this fresh zero-picked main, then leave a new fully approved round for the formal chain. */
|
|
export async function exerciseReviewLifecycle(context, fixture, { readInventory }) {
|
|
const path = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
|
|
const proof = context.createdResources.dispatchWorkflowReviews = { marker: context.marker, dispatchNo: fixture.dispatchNo,
|
|
status: 'CHECKING', commands: [], rejections: [], snapshots: {}, syntheticTestMaterials: true }
|
|
const request = async (method, target, body, label, reject = false) => {
|
|
if (method !== 'GET') { proof.commands.push({ method, path: target, body: clone(body) }); await context.checkpoint() }
|
|
const response = await context.request(method, target, body)
|
|
if (reject) {
|
|
const denied = [200, 409].includes(response.http) && ['A0409', '409'].includes(String(response.body?.code))
|
|
context.assert(MODULE, label, response, denied, '', OPTIONS); assert(denied)
|
|
proof.rejections.push({ label, http: response.http, code: response.body.code, requestId: response.requestId, traceId: response.traceId })
|
|
return response
|
|
}
|
|
const data = context.apiSuccess(MODULE, label, response, '', OPTIONS)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200'); assert(data); return data
|
|
}
|
|
const get = (target, label) => request('GET', target, undefined, label)
|
|
const snapshot = async label => {
|
|
const data = { main: await get(path, label), items: await get(`${path}/items`, label), route: await get(`${path}/route`, label), stock: [] }
|
|
for (const member of fixture.members) data.stock.push(await readInventory({ marker: context.marker, customerId: member.customerId, warehouseId: fixture.warehouseId }))
|
|
proof.snapshots[label] = data; await context.checkpoint(); return data
|
|
}
|
|
const initial = await snapshot('INITIAL_APPROVED_ZERO_PICK')
|
|
assert.equal(initial.main.stage, 'LOADING'); assert.equal(initial.main.reviewState, 'APPROVED')
|
|
assert.equal(Number(initial.main.counts.pickedPackageCount), 0); assert.equal(Number(initial.main.counts.shippedPackageCount), 0)
|
|
const key = label => `${context.marker}-REV-${label}`
|
|
let result = await request('POST', `${path}/return-to-review`, { recordVersion: initial.main.recordVersion, idempotencyKey: key('RETURN'), reason: 'TEST零扫码显式退回改货改车' }, 'Zero-pick explicit return')
|
|
assert.equal(result.stage, 'BEFORE_LOADING')
|
|
let before = await snapshot('RETURNED')
|
|
assert.equal(before.main.reviewState, 'DRAFT')
|
|
await request('POST', `${path}/submit-review`, { recordVersion: initial.main.recordVersion, idempotencyKey: key('STALE'), remark: context.marker }, 'Stale main version is rejected', true)
|
|
assert.deepEqual(await snapshot('AFTER_STALE'), before)
|
|
const submit = { recordVersion: before.main.recordVersion, idempotencyKey: key('SUBMIT-REJECT-ROUND'), remark: 'TEST第一重提轮次' }
|
|
result = await request('POST', `${path}/submit-review`, submit, 'Submit dispatch rejection round')
|
|
before = await snapshot('SUBMITTED')
|
|
const replay = await request('POST', `${path}/submit-review`, submit, 'Original submit key replays')
|
|
assert.equal(replay.replayed, true); assert.equal(String(replay.recordVersion), String(result.recordVersion))
|
|
await request('POST', `${path}/submit-review`, { ...submit, remark: 'TEST同键异载荷不得复用' }, 'Changed payload with original key is rejected', true)
|
|
await request('POST', `${path}/submit-review`, { ...submit, recordVersion: before.main.recordVersion, idempotencyKey: key('DUPLICATE-SUBMIT') }, 'New-key duplicate submit is rejected', true)
|
|
assert.deepEqual(await snapshot('AFTER_DUPLICATE_REJECTIONS'), before)
|
|
result = await request('POST', `${path}/dispatch-review`, { recordVersion: before.main.recordVersion, idempotencyKey: key('DISPATCH-REJECT'), decision: 'REJECTED', reason: 'TEST调度驳回' }, 'Dispatch reviewer rejects')
|
|
let detail = await get(path, 'Read dispatch rejection')
|
|
assert.equal(detail.reviewState, 'DISPATCH_REJECTED'); assert.equal(detail.reviews.dispatchReview.status, 'REJECTED')
|
|
result = await request('POST', `${path}/submit-review`, { recordVersion: detail.recordVersion, idempotencyKey: key('SUBMIT-LOADING-REJECT'), remark: 'TEST驳回重提' }, 'Resubmit after dispatch rejection')
|
|
result = await request('POST', `${path}/dispatch-review`, { recordVersion: result.recordVersion, idempotencyKey: key('DISPATCH-APPROVE'), decision: 'APPROVED', reason: 'TEST调度通过' }, 'Dispatch approves new round')
|
|
result = await request('POST', `${path}/loading-review`, { recordVersion: result.recordVersion, idempotencyKey: key('LOADING-REJECT'), decision: 'REJECTED', reason: 'TEST理货驳回' }, 'Loading reviewer rejects')
|
|
detail = await get(path, 'Read loading rejection')
|
|
assert.equal(detail.reviewState, 'LOADING_REJECTED'); assert.equal(detail.reviews.loadingReview.status, 'REJECTED')
|
|
const second = fixture.members[1]
|
|
result = await request('POST', `${path}/items/${encodeURIComponent(second.dispatchItemId)}/remove`, {
|
|
recordVersion: detail.recordVersion, idempotencyKey: key('REMOVE-SECOND'), reason: 'TEST零扫码先移出一票再真实重选' }, 'Remove only unpicked second member')
|
|
const removed = await snapshot('SECOND_REMOVED')
|
|
assert.equal(Number(removed.main.counts.packageCount), 1); assert.equal(removed.items.items.length, 1)
|
|
assert(removed.route.stops.every(stop => stop.destinationKey !== second.destination.key))
|
|
const candidates = await get(`${ROOT}/dispatches/candidates?${new URLSearchParams({ warehouseId: fixture.warehouseId, orderNo: second.incomingNo })}`, 'Read freshly released source candidate')
|
|
const choices = candidates.candidates?.filter(row => id(row.customerId) === second.customerId && id(row.selection?.warehousePalletId) === second.palletId && row.palletNo === second.palletNo)
|
|
assert.equal(choices?.length, 1); const choice = choices[0]
|
|
assert(choice.selection && choice.sourceVersion && choice.blockReasons?.length === 0 && Number(choice.availablePackages) === 1)
|
|
result = await request('POST', `${path}/items`, { recordVersion: result.recordVersion, idempotencyKey: key('ADD-SECOND'),
|
|
cargo: [{ ...choice.selection, warehousePalletId: second.palletId, sourceVersion: choice.sourceVersion }], batchAllocations: [] }, 'Re-add exact released current source')
|
|
const added = await snapshot('SECOND_RESTORED')
|
|
assert.equal(added.items.items.length, 2); assert.equal(Number(added.main.counts.packageCount), 2)
|
|
const replacement = added.items.items.filter(row => id(row.customerId) === second.customerId && id(row.warehousePalletId) === second.palletId)
|
|
assert.equal(replacement.length, 1); second.dispatchItemId = id(replacement[0].dispatchItemId)
|
|
const nextPlate = `FT-${context.marker.slice(-12)}-R2`
|
|
const vehicle = await request('POST', `${ROOT}/master-data/vehicles`, { plateNumber: nextPlate, model: 'Box Truck', fuelConsumptionPer100Km: 12.5,
|
|
mileageKm: 100, region: 'OVERSEAS', ownership: 'OWNED', status: 'IN_SERVICE', maxPalletSpaces: 30, maxLoadKg: 18000, maxVolumeCbm: 90,
|
|
remark: `${context.marker} TEST零扫码改派自有车辆` }, 'Create owned replacement TEST vehicle')
|
|
const update = { recordVersion: result.recordVersion, idempotencyKey: key('CHANGE-VEHICLE'), vehicle: { mode: 'MASTER', vehicleId: id(vehicle.id) },
|
|
driver: { mode: 'MASTER', driverId: fixture.tripProof.driverId, evidence: { expectedTaskEndAt: fixture.tripProof.expectedDriverEndAt } },
|
|
plannedDepartureAt: new Date(Date.now() + 3600000).toISOString(), estimatedArrivalAt: null, remark: `${context.marker} TEST零扫码改车需两级重审` }
|
|
result = await request('PUT', path, update, 'Change resources before re-review')
|
|
detail = await get(path, 'Resource edit invalidates old approvals')
|
|
assert.equal(detail.reviewState, 'DRAFT'); assert.equal(id(detail.vehicleInfo.vehicle.vehicleId), id(vehicle.id))
|
|
assert.notEqual(id(vehicle.id), fixture.tripProof.vehicleId)
|
|
for (const [action, suffix] of [['submit-review', 'FINAL-SUBMIT'], ['dispatch-review', 'FINAL-DISPATCH'], ['loading-review', 'FINAL-LOADING']]) {
|
|
result = await request('POST', `${path}/${action}`, { recordVersion: result.recordVersion, idempotencyKey: key(suffix),
|
|
...(action === 'submit-review' ? { remark: 'TEST变更后重审' } : { decision: 'APPROVED', reason: 'TEST新依据重审通过' }) }, `Final new round ${action}`)
|
|
}
|
|
const final = await snapshot('REAPPROVED_ZERO_PICK')
|
|
assert.equal(final.main.stage, 'LOADING'); assert.equal(final.main.reviewState, 'APPROVED')
|
|
assert(Number(final.main.reviews.dispatchReview.reviewRound) > Number(initial.main.reviews.dispatchReview.reviewRound))
|
|
assert.equal(final.main.reviews.dispatchReview.reviewRound, final.main.reviews.loadingReview.reviewRound)
|
|
assert.deepEqual(final.stock, initial.stock, 'All zero-pick review and cargo/resource edits preserve complete inventory')
|
|
const fleet = await get(`${ROOT}/fleet/trips/${encodeURIComponent(fixture.tripNo)}`, 'Read same main updated trip resources and route')
|
|
assert.equal(fleet.trip.tripNo, fixture.tripNo); assert.equal(id(fleet.trip.vehicleId), id(vehicle.id))
|
|
assert.equal(fleet.dispatches.length, 1); assert.equal(fleet.dispatches[0].dispatchNo, fixture.dispatchNo)
|
|
Object.assign(fixture.tripProof, { marker: nextPlate, vehicleId: id(vehicle.id), vehicle: final.main.vehicleInfo.vehicle,
|
|
vehicleInfo: final.main.vehicleInfo, driver: final.main.vehicleInfo.driver, updateRequest: update, trip: fleet.trip,
|
|
stops: fleet.trip.stops, fleetRecordVersion: fleet.trip.recordVersion, recordVersion: final.main.recordVersion })
|
|
proof.membersAfterEdit = clone(fixture.members); proof.finalVehicleInfo = clone(final.main.vehicleInfo)
|
|
proof.status = 'VERIFIED'; await context.checkpoint(); return proof
|
|
}
|
|
|
|
export async function verifyReviewExtension(context, fixture, options) {
|
|
await exerciseReviewLifecycle(context, fixture, options)
|
|
return verifyDualDestination(context, fixture, options)
|
|
}
|
|
|
|
export function assertConfirmedRelabelCancellation(before, after, outbound, stockBefore, stockAfter) {
|
|
assert.equal(before.application.status, 'READY_FOR_OUTBOUND')
|
|
assert(before.application.customerConfirmedAt && before.application.outboundOrderNo)
|
|
assert.equal(after.application.relabelNo, before.application.relabelNo)
|
|
assert.equal(after.application.customerConfirmedAt, before.application.customerConfirmedAt)
|
|
assert.equal(after.application.status, 'READY_FOR_OUTBOUND')
|
|
assert.equal(after.application.deliveryMethod, before.application.deliveryMethod)
|
|
assert.equal(after.application.outboundOrderNo ?? null, null)
|
|
assert.equal(after.application.fulfillmentStatus, 'WAIT_OUTBOUND_CREATION')
|
|
assert.deepEqual(after.items, before.items)
|
|
assert.equal(outbound.outbound.status, 'CANCELLED')
|
|
assert.equal(outbound.outbound.outboundNo, before.application.outboundOrderNo)
|
|
assert.deepEqual(stockAfter, stockBefore, 'Zero-scan cancellation preserves all completed relabel stock and immutable ledger rows')
|
|
}
|
|
|
|
/** 独立第三客户三箱正式实收；不改变正常链两个客户的一箱库存基线。 */
|
|
export async function exerciseRelabelExtensions(context, fixture, { readInventory }) {
|
|
const proof = context.createdResources.dispatchWorkflowRelabel = { marker: context.marker, status: 'PREPARING',
|
|
syntheticTestMaterials: true, hardwareVerified: false, physicalMeasurementVerified: false,
|
|
scenarios: [], sharedDispatches: [], nonTruckRearrangement: 'NOT_TESTED_NO_FORMAL_PUBLIC_ENTRY' }
|
|
const key = label => `${context.marker}-RL-${label}`
|
|
const api = async (method, path, body, token) => {
|
|
const response = await context.request(method, path, body, token)
|
|
const data = context.apiSuccess(MODULE, 'Formal relabel extension HTTP', response, '', OPTIONS)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200'); return data
|
|
}
|
|
const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aH1kAAAAASUVORK5CYII=', 'base64')
|
|
const upload = async (path, name) => {
|
|
const response = await context.requestMultipart('POST', path, { name, type: 'image/png', content: png }, fixture.pdaToken)
|
|
const data = context.apiSuccess(MODULE, 'Upload explicitly synthetic TEST relabel evidence', response, '', OPTIONS)
|
|
assert.equal(String(response.body?.code), '200'); assert(data?.fileId); return id(data.fileId)
|
|
}
|
|
const master = await api('GET', `/api/platform/v1/warehouse-admin/${encodeURIComponent(fixture.members[0].destination.warehouseId)}?tenantId=0`)
|
|
const address = master.addresses?.find(row => row.addressLine1)
|
|
assert(address && master.warehouse?.status === 'ACTIVE')
|
|
const child = Object.create(context)
|
|
child.marker = `${context.marker}-RELABEL`; child.options = { ...context.options, customerName: `TEST换标扩展-${context.marker.slice(-12)}` }
|
|
child.context = {}; child.createdResources = {}
|
|
child.request = async (...args) => context.request(...args)
|
|
await createQualifiedMerchant(child, { publishEnvironment: false })
|
|
const credentials = child.context.merchantQualificationFixture
|
|
assert(credentials?.tenantId && credentials.marker === child.marker)
|
|
proof.customerId = id(credentials.tenantId); proof.qualification = clone(child.createdResources.merchantQualificationFixture)
|
|
let session
|
|
try { session = await api('POST', '/api/auth/login', { loginId: credentials.username, password: credentials.password }, '') }
|
|
finally { delete child.context.merchantQualificationFixture }
|
|
assert(session?.accessToken && session.refreshToken)
|
|
const merchantToken = session.accessToken, customerId = proof.customerId
|
|
const stock = () => readInventory({ marker: context.marker, customerId, warehouseId: fixture.warehouseId })
|
|
try {
|
|
const profile = await api('GET', '/api/merchant/v1/iam/tenant/profile', undefined, merchantToken)
|
|
assert.equal(id(profile.id), customerId)
|
|
const skuCode = `RL-${context.marker.slice(-12)}`
|
|
const merchantRoot = '/api/merchant/v1/last-leg/warehouse-transfers'
|
|
const create = { sourceLastlegOrderIds: [], operatingWarehouseId: fixture.warehouseId,
|
|
fbaWarehouseCode: master.warehouse.warehouseCode, destinationType: 'FBA', destinationWarehouseId: id(master.warehouse.id),
|
|
destinationWarehouseCode: master.warehouse.warehouseCode, destinationWarehouseName: master.warehouse.warehouseName,
|
|
deliveryAddress: [address.countryCode, address.stateProvince, address.city, address.addressLine1, address.postalCode].filter(Boolean).join(' '),
|
|
packageCount: 3, volumeCbm: 3, deliveryMethod: 'CUSTOMER_DELIVERY', estimatedArrivalAt: new Date(Date.now() + 3600000).toISOString().slice(0, 19),
|
|
needRelabel: false, remark: `${context.marker} TEST三箱换标独立来货`, idempotencyKey: key('RECEIPT-CREATE'),
|
|
items: [{ skuCode, productNameZh: 'TEST三箱换标货物', packageCount: 3, quantity: 3 }] }
|
|
proof.receiptCreate = clone(create); await context.checkpoint()
|
|
let incoming = await api('POST', merchantRoot, create, merchantToken)
|
|
proof.incomingNo = incoming.transferNo; assert(proof.incomingNo)
|
|
const merchantPath = `${merchantRoot}/${encodeURIComponent(proof.incomingNo)}`
|
|
incoming = await api('POST', `${merchantPath}/submit`, undefined, merchantToken)
|
|
incoming = await api('POST', `${ROOT}/warehouse-transfers/${encodeURIComponent(proof.incomingNo)}/review?customerId=${customerId}`,
|
|
{ decision: 'APPROVE', remark: `${context.marker} TEST三箱独立实收` })
|
|
assert.equal(incoming.status, 'WAIT_PDA_RECEIVING')
|
|
const pda = `/api/pda/v1/last-leg/warehouse-transfers/${encodeURIComponent(proof.incomingNo)}`
|
|
const task = await api('GET', pda, undefined, fixture.pdaToken)
|
|
assert.equal(Number(task.packageCount), 3); assert.equal(task.items.length, 1); assert.equal(task.cartons.length, 3)
|
|
assert.equal(task.items[0].skuCode, skuCode); assert.equal(Number(task.items[0].quantity), 3)
|
|
assert.equal(new Set(task.cartons.map(row => row.cartonMark)).size, 3)
|
|
const draft = await api('POST', `${pda}/pallets/drafts`, { idempotencyKey: key('DRAFT') }, fixture.pdaToken)
|
|
assert.equal(draft.pallets.length, 1)
|
|
const palletPath = `${pda}/pallets/${encodeURIComponent(draft.pallets[0].id)}`
|
|
const generated = await api('POST', `${palletPath}/generate`, { idempotencyKey: key('GENERATE') }, fixture.pdaToken)
|
|
const pallet = generated.pallets[0]; assert(pallet.warehousePalletId && pallet.palletNo)
|
|
await api('POST', `${palletPath}/bind`, { palletCode: pallet.palletNo, idempotencyKey: key('BIND') }, fixture.pdaToken)
|
|
const counted = await api('POST', `${pda}/cartons/count`, { forecastPackageCount: 3, idempotencyKey: key('COUNT'),
|
|
boxes: task.cartons.map(carton => ({ cartonMark: carton.cartonMark, transferItemId: id(task.items[0].id), transferPalletId: id(draft.pallets[0].id),
|
|
length: 100, width: 100, height: 100, weight: 100, items: [{ skuCode, quantity: 1 }] })) }, fixture.pdaToken)
|
|
assert.equal(counted.cartons.length, 3); assert(counted.cartons.every(row => row.status === 'COUNTED' && Number(row.quantity) === 1))
|
|
assert.equal(Number(counted.pallets[0].cartonCount), 3); assert.equal(Number(counted.pallets[0].grossWeightKg), 300)
|
|
const photoId = await upload(`${pda}/measurement-photos/files`, `${context.marker}-TEST-three-boxes.png`)
|
|
incoming = await api('POST', `${pda}/palletize`, { idempotencyKey: key('PALLETIZE'), photoFileIds: [photoId] }, fixture.pdaToken)
|
|
assert.equal(incoming.status, 'WAIT_CUSTOMER_CONFIRMATION')
|
|
incoming = await api('POST', `${merchantPath}/confirm-measurement`, { idempotencyKey: key('CONFIRM-RECEIPT'), remark: context.marker }, merchantToken)
|
|
assert.equal(incoming.status, 'READY_FOR_DISPATCH')
|
|
proof.receipt = await stock()
|
|
assert.equal(proof.receipt.balances.length, 1); assert.equal(proof.receipt.positions.length, 1); assert.equal(proof.receipt.ledger.length, 1)
|
|
assert.equal(Number(proof.receipt.balances[0].availablePackages), 3)
|
|
assert.equal(id(proof.receipt.positions[0].palletId), id(pallet.warehousePalletId))
|
|
const candidates = await api('GET', `/api/merchant/v1/last-leg/relabel-applications/inventory-candidates?operationWarehouseId=${fixture.warehouseId}`, undefined, merchantToken)
|
|
const sources = candidates.filter(row => id(row.inventoryBalanceId) === id(proof.receipt.balances[0].id) && row.inboundCode === proof.incomingNo)
|
|
assert.equal(sources.length, 1); const source = sources[0]
|
|
const positions = source.positions.filter(row => id(row.positionId) === id(proof.receipt.positions[0].id))
|
|
assert.equal(positions.length, 1); assert.equal(Number(positions[0].availablePackages), 3)
|
|
const resolve = code => api('POST', '/api/pda/v1/last-leg/pallet-operations/pallets/resolve', { code }, fixture.pdaToken)
|
|
let sharedTarget
|
|
for (const [index, method] of ['TRUCK', 'TRUCK', 'PICKUP'].entries()) {
|
|
const name = `${method}-${index + 1}`, scenario = { name, operationType: 'CARTON_LABEL', deliveryMethod: method }
|
|
proof.scenarios.push(scenario)
|
|
const item = { sourceInventoryBalanceId: id(source.inventoryBalanceId), sourceInventoryPositionId: id(positions[0].positionId),
|
|
sourceInboundOrderId: id(source.inboundOrderId), skuCode, productNameZh: 'TEST三箱换标货物', totalPackageCount: 1, notifiedPackageCount: 1,
|
|
shipmentNo: `TEST-RL-${context.marker.slice(-12)}-${index + 1}`, cartonMark: task.cartons[index].cartonMark,
|
|
fbaCartonMark: `TEST-NEW-${context.marker.slice(-12)}-${index + 1}`, destinationFbaWarehouseCode: master.warehouse.warehouseCode,
|
|
operationType: 'CARTON_LABEL', skuItems: [], labelRequirement: `${context.marker} TEST换标成果` }
|
|
scenario.createBody = { customerOrderNo: `TEST-${context.marker.slice(-12)}-${name}`, operationWarehouseId: fixture.warehouseId,
|
|
labelDeadline: new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 19), contactName: 'TEST换标验收', contactPhone: '19900000000',
|
|
remark: context.marker, idempotencyKey: key(`${name}-CREATE`), deliveryMethod: method, printShippingLabel: false, items: [item] }
|
|
await context.checkpoint()
|
|
const created = await api('POST', `${ROOT}/relabel-applications?customerId=${customerId}`, scenario.createBody)
|
|
scenario.relabelNo = created.application.relabelNo; assert(scenario.relabelNo)
|
|
assert.equal(created.application.status, 'PENDING_REVIEW')
|
|
assert(created.application.lastlegOrderId)
|
|
const approved = await api('PUT', `${ROOT}/orders/${encodeURIComponent(created.application.lastlegOrderId)}/relabel-review?customerId=${customerId}`,
|
|
{ status: 'PENDING_PROCESSING', remark: `${context.marker} TEST正式审核后允许PDA作业` })
|
|
assert.equal(approved.application.status, 'PENDING_PROCESSING'); scenario.approved = clone(approved)
|
|
const taskRoot = `/api/pda/v1/last-leg/relabel-tasks/${encodeURIComponent(scenario.relabelNo)}`
|
|
let detail = await api('POST', `${taskRoot}/claim`, { idempotencyKey: key(`${name}-CLAIM`) }, fixture.pdaToken)
|
|
assert.equal(detail.items.length, 1)
|
|
detail = await api('POST', `${taskRoot}/units`, { itemId: id(detail.items[0].itemId), oldLabel: item.cartonMark, newLabel: item.fbaCartonMark,
|
|
skuVerifications: [], expectedVersion: detail.version, idempotencyKey: key(`${name}-SCAN`) }, fixture.pdaToken)
|
|
let target
|
|
if (index === 1) target = sharedTarget
|
|
else target = await api('POST', '/api/pda/v1/last-leg/pallet-operations/relabel-pallet-label', { relabelNo: scenario.relabelNo,
|
|
idempotencyKey: key(`${name}-LABEL`) }, fixture.pdaToken)
|
|
assert(target?.palletId && target.palletCode); if (index === 0) sharedTarget = target
|
|
const from = await resolve(pallet.palletNo), to = await resolve(target.palletCode)
|
|
await api('POST', '/api/pda/v1/last-leg/pallet-operations/relabel-disassemble', { relabelNo: scenario.relabelNo,
|
|
idempotencyKey: key(`${name}-MOVE`), source: { palletCode: from.palletCode, expectedVersion: from.palletVersion },
|
|
target: { palletCode: to.palletCode, expectedVersion: to.palletVersion }, cartonMarks: [item.cartonMark], reason: `${context.marker} TEST实际箱移绑` }, fixture.pdaToken)
|
|
scenario.targets = [clone(target)]
|
|
const fileId = await upload(`${taskRoot}/photos/files`, `${context.marker}-${name}-TEST.png`)
|
|
detail = await api('POST', `${taskRoot}/complete`, { photoFileIds: [fileId], expectedVersion: detail.version,
|
|
idempotencyKey: key(`${name}-COMPLETE`), remark: context.marker }, fixture.pdaToken)
|
|
assert.equal(detail.applicationStatus, 'CUSTOMER_CONFIRM_PENDING')
|
|
const confirmed = await api('POST', `/api/merchant/v1/last-leg/relabel-applications/${encodeURIComponent(scenario.relabelNo)}/confirm-completion`,
|
|
{ idempotencyKey: key(`${name}-CONFIRM`), remark: context.marker }, merchantToken)
|
|
assert.equal(confirmed.application.status, 'READY_FOR_OUTBOUND'); assert(confirmed.application.customerConfirmedAt)
|
|
scenario.confirmed = clone(confirmed); scenario.items = clone(confirmed.items); scenario.relabelVerified = true
|
|
scenario.destinationFbaWarehouseCode = master.warehouse.warehouseCode
|
|
await context.checkpoint()
|
|
}
|
|
proof.sharedPhysical = await resolve(sharedTarget.palletCode)
|
|
assert.equal(Number(proof.sharedPhysical.totalPackages), 2)
|
|
const pickup = proof.scenarios[2], relabelPath = `${ROOT}/relabel-applications/${encodeURIComponent(pickup.relabelNo)}`
|
|
const before = await api('GET', relabelPath), stockBefore = await stock()
|
|
assert.equal(before.application.fulfillmentStatus, 'OUTBOUND_CREATED'); assert(before.application.outboundOrderNo)
|
|
const outboundPath = `${ROOT}/outbound-orders/${encodeURIComponent(before.application.outboundOrderNo)}`
|
|
const outboundBefore = await api('GET', outboundPath)
|
|
assert(['WAIT_PICK', 'WAIT_OUTBOUND'].includes(outboundBefore.outbound.status))
|
|
proof.cancel = { status: 'INTENT', before, stockBefore, outboundBefore, body: { reason: `${context.marker} TEST已确认换标零扫码撤销本次出库安排` } }
|
|
await context.checkpoint()
|
|
await api('POST', `${outboundPath}/cancel`, proof.cancel.body)
|
|
const after = await api('GET', relabelPath), outboundAfter = await api('GET', outboundPath), stockAfter = await stock()
|
|
Object.assign(proof.cancel, { after, outboundAfter, stockAfter })
|
|
assertConfirmedRelabelCancellation(before, after, outboundAfter, stockBefore, stockAfter)
|
|
proof.cancel.status = 'VERIFIED'; await context.checkpoint()
|
|
context.assert(MODULE, 'Confirmed relabel zero-scan outbound cancellation preserves completed items, customer confirmation and all raw stock', null, true, '', OPTIONS)
|
|
await verifyRelabelSharedDispatches(context, fixture, { readInventory }, proof)
|
|
return proof
|
|
} finally {
|
|
await api('POST', '/api/auth/logout', { refreshToken: session.refreshToken }, merchantToken)
|
|
proof.ownedMerchantSessionClosed = true; await context.checkpoint()
|
|
}
|
|
}
|
|
|
|
export async function verifyRelabelSharedDispatches(context, fixture, { readInventory }, proof) {
|
|
const customerId = proof.customerId, truck = proof.scenarios.slice(0, 2)
|
|
const stock = () => readInventory({ marker: context.marker, customerId, warehouseId: fixture.warehouseId })
|
|
const api = async (method, path, body) => {
|
|
const response = await context.request(method, path, body)
|
|
const data = context.apiSuccess(MODULE, 'Exact owned relabel shared physical selection', response, '', OPTIONS)
|
|
assert.equal(String(response.body?.code), '200'); return data
|
|
}
|
|
assert.equal(proof.cancel.status, 'VERIFIED'); assert.equal(truck.length, 2)
|
|
assert(truck.every(row => row.relabelVerified && row.deliveryMethod === 'TRUCK'))
|
|
proof.status = 'CHECKING_SHARED_NATIVE'
|
|
for (const round of [1, 2]) {
|
|
const byKey = new Map()
|
|
for (const scenario of truck) {
|
|
const page = await api('GET', `${ROOT}/dispatches/candidates?${new URLSearchParams({ warehouseId: fixture.warehouseId,
|
|
sourceStage: 'RELABEL', orderNo: scenario.relabelNo })}`)
|
|
assert.equal(page.complete, true)
|
|
for (const row of page.candidates) {
|
|
assert(truck.some(item => item.relabelNo === row.selection?.relabelNo))
|
|
const prior = byKey.get(row.sourceKey)
|
|
if (prior) assert.deepEqual(prior, row)
|
|
byKey.set(row.sourceKey, row)
|
|
}
|
|
}
|
|
const rows = [...byKey.values()]
|
|
assert.equal(rows.length, 2); assert.equal(new Set(rows.map(row => id(row.selection.warehousePalletId))).size, 1)
|
|
const createBody = nativeRelabelCreateBody(`${context.marker}-ROUND-${round}`, truck, rows, customerId, fixture.warehouseId)
|
|
const run = { round, status: 'INTENT', createBody, stockBefore: await stock() }; proof.sharedDispatches.push(run); await context.checkpoint()
|
|
run.result = await api('POST', `${ROOT}/dispatches`, createBody)
|
|
assert(run.result.dispatchNo)
|
|
const path = `${ROOT}/dispatches/${encodeURIComponent(run.result.dispatchNo)}`
|
|
run.detail = await api('GET', path); run.items = await api('GET', `${path}/items`)
|
|
assert.equal(Number(run.detail.counts.packageCount), 2); assert.equal(Number(run.detail.counts.palletCount), 1)
|
|
assert.equal(Number(run.detail.counts.pickedPackageCount), 0); assert.equal(run.items.items.length, 2)
|
|
assert.equal(new Set(run.items.items.map(row => id(row.warehousePalletId))).size, 1)
|
|
assert(run.items.items.every(row => id(row.customerId) === customerId && Number(row.scheduledPackages) === 1))
|
|
run.cancelBody = { recordVersion: run.detail.recordVersion, idempotencyKey: `${context.marker}-RL-SHARED-${round}-CANCEL`, reason: `${context.marker} TEST零扫码验证后撤销安排保留换标成果` }
|
|
await context.checkpoint(); run.cancelled = await api('POST', `${path}/cancel`, run.cancelBody)
|
|
assert.equal(run.cancelled.status, 'CANCELLED'); run.stockAfter = await stock(); assert.deepEqual(run.stockAfter, run.stockBefore)
|
|
for (const scenario of truck) {
|
|
const current = await api('GET', `${ROOT}/relabel-applications/${encodeURIComponent(scenario.relabelNo)}`)
|
|
assert.equal(current.application.status, 'READY_FOR_OUTBOUND'); assert.equal(current.application.customerConfirmedAt, scenario.confirmed.application.customerConfirmedAt)
|
|
assert.deepEqual(current.items, scenario.confirmed.items)
|
|
}
|
|
run.status = 'VERIFIED'; await context.checkpoint()
|
|
}
|
|
assert.notEqual(proof.sharedDispatches[0].result.dispatchNo, proof.sharedDispatches[1].result.dispatchNo)
|
|
context.assert(MODULE, 'Two confirmed applications share one actual pallet without double counting and can be natively rearranged after zero-pick cancellation', null, true, '', OPTIONS)
|
|
proof.status = 'VERIFIED_WITH_NON_TRUCK_REARRANGEMENT_GAP'; await context.checkpoint(); return proof
|
|
}
|
|
|
|
export async function reconcileRelabelShared(context, fixture, options, prior) {
|
|
const proof = context.createdResources.dispatchWorkflowRelabel = clone(prior.createdResources.dispatchWorkflowRelabel)
|
|
assert.equal(proof.sharedDispatches.length, 0); assert.equal(proof.cancel.status, 'VERIFIED')
|
|
assert(proof.scenarios.every(row => row.relabelVerified === true))
|
|
const read = async path => {
|
|
const response = await context.request('GET', path)
|
|
assert.equal(String(response.body?.code), '200'); return response.body.data
|
|
}
|
|
const main = await read(`${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`)
|
|
const trip = await read(`${ROOT}/fleet/trips/${encodeURIComponent(fixture.tripNo)}`)
|
|
assert.equal(main.stage, 'DELIVERED'); assert.equal(trip.trip.status, 'COMPLETED')
|
|
assert(trip.trip.vehicleRelease && trip.trip.driverRelease)
|
|
const currentStock = await options.readInventory({ marker: context.marker, customerId: proof.customerId, warehouseId: fixture.warehouseId })
|
|
assert.deepEqual(currentStock, proof.cancel.stockAfter)
|
|
for (const scenario of proof.scenarios) {
|
|
const current = await read(`${ROOT}/relabel-applications/${encodeURIComponent(scenario.relabelNo)}`)
|
|
assert.equal(current.application.status, 'READY_FOR_OUTBOUND'); assert.equal(current.application.customerConfirmedAt, scenario.confirmed.application.customerConfirmedAt)
|
|
assert.deepEqual(current.items, scenario.confirmed.items)
|
|
}
|
|
await verifyRelabelSharedDispatches(context, fixture, options, proof)
|
|
context.createdResources.fleetCrossCustomer = clone(prior.createdResources.fleetCrossCustomer)
|
|
return context.createdResources.fleetCrossCustomer
|
|
}
|
|
|
|
export async function verifyRelabelExtension(context, fixture, options) {
|
|
const verified = await verifyDualDestination(context, fixture, options)
|
|
try { await exerciseRelabelExtensions(context, fixture, options) }
|
|
catch (error) {
|
|
if (!context.createdResources.fleetWriteBoundary && !fixture.tripProof.closure) await finishFleetTrip(context, MODULE, fixture.tripProof)
|
|
throw error
|
|
}
|
|
return verified
|
|
}
|
|
|
|
/** Read-only terminal reconciliation after the known sequential-read completion race; never replay fulfillment. */
|
|
export async function reconcileReviewTerminal(context, fixture, { readInventory }, prior) {
|
|
assert.equal(prior.success, false)
|
|
assert.equal(prior.error, 'Native main/items/PDA retain both true customers and physical pallets')
|
|
assert.equal(prior.createdResources.dispatchWorkflowReviews.status, 'VERIFIED')
|
|
assert.equal(prior.createdResources.fleetWriteBoundary, undefined)
|
|
const old = prior.createdResources.fleetCrossCustomer, path = `${ROOT}/dispatches/${encodeURIComponent(fixture.dispatchNo)}`
|
|
assert.equal(old.dispatchNo, fixture.dispatchNo); assert.equal(old.marker, context.marker)
|
|
assert(old.requests.filter(row => row.label === 'Attach receipt to independently complete this delivery').length === 2)
|
|
assert(old.requests.every(row => row.status === 'RESPONDED'))
|
|
const get = async target => {
|
|
const response = await context.request('GET', target)
|
|
const data = context.apiSuccess(MODULE, 'Explicit terminal reconciliation read only', response, '', OPTIONS)
|
|
assert.equal(response.http, 200); assert.equal(String(response.body?.code), '200'); assert(data); return data
|
|
}
|
|
const current = { trip: await get(`${ROOT}/fleet/trips/${encodeURIComponent(fixture.tripNo)}`), dispatch: await get(path),
|
|
items: await get(`${path}/items`), task: null, members: [] }
|
|
const pda = await context.request('GET', `/api/pda/v1/last-leg/dispatches/${encodeURIComponent(fixture.dispatchNo)}`, undefined, fixture.pdaToken)
|
|
assert.equal(pda.http, 200); assert.equal(String(pda.body?.code), '200'); current.task = pda.body.data
|
|
assert.equal(current.dispatch.stage, 'DELIVERED'); assert.equal(current.dispatch.status, 'ACTIVE')
|
|
for (const value of [current.items, current.task]) {
|
|
assert.equal(value.dispatchNo, fixture.dispatchNo); assert.equal(value.stage, 'DELIVERED')
|
|
assert.equal(id(value.recordVersion), id(current.dispatch.recordVersion)); assert.equal(value.items.length, 2)
|
|
}
|
|
for (const field of ['packageCount', 'pickedPackageCount', 'shippedPackageCount']) assert.equal(Number(current.dispatch.counts[field]), 2)
|
|
assert.equal(current.trip.trip.tripNo, fixture.tripNo)
|
|
assert.equal(id(current.trip.trip.vehicleId), fixture.tripProof.vehicleId); assert.equal(id(current.trip.trip.driverId), fixture.tripProof.driverId)
|
|
assert.equal(current.trip.dispatches.length, 1); assert.equal(current.trip.dispatches[0].dispatchNo, fixture.dispatchNo)
|
|
const extension = context.createdResources.dispatchWorkflowExtensions = clone(prior.createdResources.dispatchWorkflowExtensions)
|
|
extension.status = 'CHECKING'; extension.explicitTerminalContinuation = true; extension.priorFailurePreserved = true
|
|
const allFeeIds = new Set()
|
|
for (const [index, member] of fixture.members.entries()) {
|
|
const oldMember = old.members[index]
|
|
assert.equal(member.customerId, oldMember.customerId); assert.equal(member.dispatchItemId, oldMember.dispatchItemId)
|
|
for (const rows of [current.items.items, current.task.items]) {
|
|
const matches = rows.filter(row => id(row.dispatchItemId) === member.dispatchItemId)
|
|
assert.equal(matches.length, 1); assert.equal(id(matches[0].customerId), member.customerId)
|
|
assert.equal(matches[0].palletNo, member.palletNo); assert.equal(Number(matches[0].pickedPackages), 1)
|
|
}
|
|
const suffix = new URLSearchParams({ customerId: member.customerId })
|
|
const outbound = await get(`${ROOT}/outbound-orders/${encodeURIComponent(oldMember.outboundNo)}?${suffix}`)
|
|
const delivery = await get(`${ROOT}/delivery-orders/${encodeURIComponent(oldMember.deliveryNo)}?${suffix}`)
|
|
assert.equal(outbound.outbound.dispatchNo, fixture.dispatchNo); assert.equal(outbound.outbound.status, 'OUTBOUNDED')
|
|
assert.equal(delivery.order.dispatchNo, fixture.dispatchNo); assert.equal(delivery.order.status, 'DELIVERED')
|
|
assert.equal(id(delivery.order.customerId), member.customerId); assert.equal(delivery.order.destinationWarehouseCode, member.destination.warehouseCode)
|
|
assert(Array.isArray(delivery.fees))
|
|
const originalFees=old.snapshots.BEFORE_SIGN_1.members[index].delivery.fees
|
|
assert(Array.isArray(originalFees)); assert.deepEqual(delivery.fees,originalFees)
|
|
for (const fee of delivery.fees) {
|
|
assert(fee.id && !allFeeIds.has(id(fee.id))); allFeeIds.add(id(fee.id))
|
|
}
|
|
const stock = await readInventory({ marker: context.marker, customerId: member.customerId, warehouseId: fixture.warehouseId })
|
|
assert.deepEqual(stock, old.snapshots.BEFORE_SIGN_1.members[index].stock, 'Terminal completion must not change already shipped inventory')
|
|
current.members.push({ outbound, delivery, stock })
|
|
}
|
|
assert.deepEqual(await get(path), current.dispatch, 'Terminal state changed during reconciliation')
|
|
const verified = context.createdResources.fleetCrossCustomer = { marker: context.marker, dispatchNo: fixture.dispatchNo,
|
|
tripNo: fixture.tripNo, warehouseId: fixture.warehouseId, members: clone(old.members), status: 'VERIFIED', snapshots: { FINAL: current },
|
|
continuation: 'TERMINAL_READONLY_AFTER_CONFIRMED_SIGNATURES', priorError: prior.error,
|
|
gateProof: old.gateProof, midTransactionRollback: 'NOT_TESTED_NO_CONTROLLED_INJECTION' }
|
|
extension.status = 'VERIFIED'; await context.checkpoint(); return verified
|
|
}
|