161 lines
10 KiB
JavaScript
161 lines
10 KiB
JavaScript
import test from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import { parsePoolArguments, poolPlan, runPoolAcceptance, assertPoolRemaining, assertSingleCommercial,
|
|
shrinkingVehicleRequest, expiryWaitMs, poolLocalDateTime, poolPickScope, pickPoolDispatch, POOL_COVERAGE, POOL_REMAINING } from './fleet-capacity-pool-test-env.mjs'
|
|
|
|
test('default and explicit plans make no network requests or invoke the mutating runner', async () => {
|
|
const original = globalThis.fetch
|
|
globalThis.fetch = async () => { throw Error('unexpected network') }
|
|
try {
|
|
for (const args of [[], ['--plan']]) {
|
|
const config = parsePoolArguments(args)
|
|
const plan = await runPoolAcceptance(config, { runner: async () => { throw Error('unexpected runner') } })
|
|
assert.equal(plan.execute, false)
|
|
assert.equal(plan.environment, 'TEST')
|
|
assert.equal(plan.runId, 'plan')
|
|
assert.match(plan.boundary, /no network or filesystem writes/)
|
|
}
|
|
} finally { globalThis.fetch = original }
|
|
})
|
|
|
|
test('execution needs explicit TEST, fresh run ID and current warehouse identifiers', () => {
|
|
for (const args of [
|
|
['--execute'], ['--execute', '--run-id', 'fresh', '--warehouse-id', '10', '--destination-warehouse-id', '11'],
|
|
['--execute', '--environment', 'gray', '--run-id', 'fresh', '--warehouse-id', '10', '--destination-warehouse-id', '11'],
|
|
['--execute', '--environment', 'TEST', '--run-id', '../reuse', '--warehouse-id', '10', '--destination-warehouse-id', '11'],
|
|
['--execute', '--plan'], ['--resume', 'old-report'],
|
|
]) assert.throws(() => parsePoolArguments(args))
|
|
const parsed = parsePoolArguments(['--execute', '--environment', 'TEST', '--run-id', 'pool-r1', '--warehouse-id', '10', '--destination-warehouse-id', '11'])
|
|
assert.equal(parsed.execute, true)
|
|
assert.equal(parsed.runId, 'pool-r1')
|
|
})
|
|
|
|
test('plan distinguishes implemented HTTP scope from remaining whole-feature acceptance', () => {
|
|
const plan = poolPlan(parsePoolArguments([]))
|
|
assert.deepEqual(plan.coveredByThisEntry, POOL_COVERAGE)
|
|
assert.deepEqual(plan.remainingSeparateAcceptance, POOL_REMAINING)
|
|
assert.ok(plan.coveredByThisEntry.includes('both-business-types-real-pda-receipt'))
|
|
assert.ok(plan.remainingSeparateAcceptance.includes('full-UI-1920x1080-and-network-request-budget'))
|
|
assert.ok(plan.coveredByThisEntry.includes('weight-and-volume-independent-capacity-rejections'))
|
|
assert.ok(plan.coveredByThisEntry.includes('paused-create-edit-confirm-rejected'))
|
|
assert.ok(plan.coveredByThisEntry.includes('expired-cutoff-create-edit-confirm-rejected'))
|
|
assert.ok(plan.coveredByThisEntry.includes('assigned-vehicle-disable-and-shrink-rejected'))
|
|
assert.ok(plan.remainingSeparateAcceptance.includes('out-of-band-assigned-vehicle-drift-not-constructible-through-supported-api'))
|
|
assert.match(plan.boundary, /unknown outcome/)
|
|
assert.match(plan.boundary, /No automatic rerun or resume/)
|
|
})
|
|
|
|
test('remaining capacity uses unique current destination and rejects unknown, other-stop or duplicate rows', () => {
|
|
const offer = { capacityKnown: true, destinations: [{ destinationKey: 'FBA:A', remaining: { palletSpaces: 4 } },
|
|
{ destinationKey: 'FBA:B', remaining: { palletSpaces: 30 } }] }
|
|
assert.doesNotThrow(() => assertPoolRemaining(offer, 'FBA:A', 4))
|
|
for (const change of [o => { o.capacityKnown = false }, o => { o.destinations[0].remaining = null },
|
|
o => { o.destinations[0].destinationKey = 'FBA:C' }, o => { o.destinations.push(structuredClone(o.destinations[0])) },
|
|
o => { o.destinations[0].remaining.palletSpaces = 5 }]) {
|
|
const altered = structuredClone(offer); change(altered)
|
|
assert.throws(() => assertPoolRemaining(altered, 'FBA:A', 4), /EXACT_SEGMENT/)
|
|
}
|
|
})
|
|
|
|
test('successful confirmation replay must preserve commercial, booking, business type and customer identity', () => {
|
|
const before = { bookingNo: 'FB-1', businessOrderNo: 'LB-1', businessType: 'LOCAL_LOOSEBOARD', customerId: '9' }
|
|
assert.doesNotThrow(() => assertSingleCommercial(before, { ...before }))
|
|
for (const field of Object.keys(before)) assert.throws(() => assertSingleCommercial(before, { ...before, [field]: 'OTHER' }), /IDENTITY_CHANGED/)
|
|
assert.throws(() => assertSingleCommercial({ ...before, businessOrderNo: null }, { ...before }), /IDENTITY_CHANGED/)
|
|
})
|
|
|
|
test('default executor rejects non-TEST process configuration before any fixture writes', async () => {
|
|
const config = parsePoolArguments(['--execute', '--environment', 'TEST', '--run-id', 'pool-r1', '--warehouse-id', '10', '--destination-warehouse-id', '11'])
|
|
await assert.rejects(runPoolAcceptance(config, { env: { CHONGCHONG_ENV: 'prod' } }), /Explicit TEST configuration/)
|
|
})
|
|
|
|
test('vehicle shrink command preserves the authoritative full request and only changes capacity by one', () => {
|
|
const vehicle = { id: '7', recordVersion: 11, plateNumber: 'TEST-7', model: 'Box Truck', fuelConsumptionPer100Km: 12.5,
|
|
mileageKm: 100, driverOrDispatchCompany: 'TEST', phone: null, region: 'OVERSEAS', ownership: 'OWNED', remark: 'own fixture',
|
|
maxPalletSpaces: 30, maxLoadKg: 18000, maxVolumeCbm: 90, status: 'IN_SERVICE' }
|
|
const request = shrinkingVehicleRequest(vehicle)
|
|
assert.equal(request.maxPalletSpaces, 29)
|
|
for (const field of Object.keys(request).filter(name => name !== 'maxPalletSpaces')) assert.equal(request[field], vehicle[field])
|
|
assert.equal('status' in request, false)
|
|
assert.equal('id' in request, false)
|
|
assert.equal(vehicle.maxPalletSpaces, 30)
|
|
})
|
|
|
|
test('vehicle matrix refuses incomplete snapshots instead of inventing capacity for a write', () => {
|
|
for (const input of [null, {}, { id: '7', recordVersion: 1, maxPalletSpaces: 30 },
|
|
{ id: '7', recordVersion: 1, maxPalletSpaces: 1, maxLoadKg: 18000, maxVolumeCbm: 90 }]) {
|
|
assert.throws(() => shrinkingVehicleRequest(input), /SNAPSHOT_REQUIRED/)
|
|
}
|
|
})
|
|
|
|
test('cutoff wait is bounded and follows the returned instant without negative or unbounded sleeps', () => {
|
|
const now = Date.parse('2030-01-01T08:00:00Z')
|
|
assert.equal(expiryWaitMs('2030-01-01T08:00:08Z', now), 8300)
|
|
assert.equal(expiryWaitMs('2030-01-01T07:59:00Z', now), 0)
|
|
assert.throws(() => expiryWaitMs('invalid', now), /INVALID_SERVER_CUTOFF/)
|
|
assert.throws(() => expiryWaitMs('2030-01-01T08:10:00Z', now), /BOUNDED_WINDOW/)
|
|
})
|
|
|
|
test('LocalDateTime transport time keeps actual local wall clock while Instant dates remain zoned', () => {
|
|
class ShanghaiDate extends Date { getTimezoneOffset() { return -480 } }
|
|
class LosAngelesDate extends Date { getTimezoneOffset() { return 420 } }
|
|
const instant = '2030-01-01T20:30:45.123Z'
|
|
assert.equal(poolLocalDateTime(new ShanghaiDate(instant)), '2030-01-02T04:30:45')
|
|
assert.equal(poolLocalDateTime(new LosAngelesDate(instant)), '2030-01-01T13:30:45')
|
|
assert.equal(new ShanghaiDate(instant).toISOString(), instant)
|
|
assert.equal(new LosAngelesDate(instant).toISOString(), instant)
|
|
assert.throws(() => poolLocalDateTime(new Date('invalid')), /VALID_LOCAL_DATE_REQUIRED/)
|
|
})
|
|
|
|
test('PDA namespace belongs to the exact run, customer and dispatch while parent evidence stays shared', () => {
|
|
const context = { marker: 'ORIGINAL-RUN', steps: [], createdResources: {} }, first = { customerId: '9', dispatchNo: 'DS-A' }
|
|
const a = poolPickScope(context, first), replay = poolPickScope(context, first)
|
|
assert.equal(a.marker, replay.marker)
|
|
assert.notEqual(a.marker, poolPickScope(context, { ...first, dispatchNo: 'DS-B' }).marker)
|
|
assert.notEqual(a.marker, poolPickScope(context, { ...first, customerId: '10' }).marker)
|
|
assert.notEqual(a.marker, poolPickScope({ ...context, marker: 'OTHER-RUN' }, first).marker)
|
|
assert.equal(a.steps, context.steps)
|
|
assert.equal(a.createdResources, context.createdResources)
|
|
assert.equal(context.marker, 'ORIGINAL-RUN')
|
|
assert.throws(() => poolPickScope(context, { dispatchNo: 'DS-A' }), /PICK_SCOPE_REQUIRED/)
|
|
})
|
|
|
|
test('real pickAll helper handles two same-customer dispatches with separate pick/complete keys and exact replays', async () => {
|
|
const operations = new Map(), requests = [], steps = [], picked = new Map()
|
|
const dispatches = ['DS-A', 'DS-B']
|
|
const context = {
|
|
marker: 'SAME-CUSTOMER-RUN', steps, createdResources: {},
|
|
addStep(_module, _name, _response, passed) { steps.push(passed) },
|
|
assert(_module, _name, _response, passed) { assert.equal(Boolean(passed), true) },
|
|
addCoverageGap() { assert.fail('unexpected coverage gap') },
|
|
async request(method, path, body) {
|
|
const dispatchNo = path.split('/dispatches/')[1].split('/')[0], index = dispatches.indexOf(dispatchNo)
|
|
assert.ok(index >= 0)
|
|
const response = data => ({ http: 200, body: { code: '200', data }, requestId: 'test', traceId: 'test' })
|
|
if (method === 'GET') return response({ items: [{ dispatchItemId: `${index + 1}`, scheduledPackages: 1,
|
|
pickedPackages: picked.get(dispatchNo) || 0, positions: [{ id: `${index + 100}`, availablePackages: 1 }] }] })
|
|
requests.push({ method, path, body: structuredClone(body) })
|
|
const prior = operations.get(body.idempotencyKey), payload = JSON.stringify([path, body])
|
|
if (prior) {
|
|
if (prior.payload !== payload) return { http: 200, body: { code: 'A0409', message: 'Idempotency key was reused with a different request' } }
|
|
return response({ ...prior.result, replayed: true })
|
|
}
|
|
let result
|
|
if (path.endsWith('/pick')) { picked.set(dispatchNo, 1); result = { pickedPackages: 1 } }
|
|
else result = { status: 'READY_TO_DEPART', plannedPackages: 1, pickedPackages: 1, remainingPackages: 0, replayed: false }
|
|
operations.set(body.idempotencyKey, { payload, result })
|
|
return response(result)
|
|
},
|
|
}
|
|
for (const dispatchNo of dispatches) await pickPoolDispatch(context, 'test-pda', { customerId: '9', dispatchNo })
|
|
assert.equal(operations.size, 4)
|
|
assert.equal(requests.length, 8)
|
|
assert.ok(steps.every(Boolean))
|
|
for (let index = 0; index < requests.length; index += 2) assert.deepEqual(requests[index], requests[index + 1])
|
|
})
|
|
|
|
test('failed helper result stops the pool stage immediately instead of appending a misleading generic failure', async () => {
|
|
const context = { marker: 'R', steps: [] }
|
|
await assert.rejects(pickPoolDispatch(context, 'test', { customerId: '9', dispatchNo: 'DS-A' }, async () => false), /PDA_PICK_FAILED:DS-A/)
|
|
})
|