475 lines
29 KiB
JavaScript
475 lines
29 KiB
JavaScript
import { findPricedOrderRouteAcrossOrigins, findPricedOrderRoute, freezeOrderCommand } from './orders.mjs'
|
|
|
|
const MODULE = 'order-inbound-status-fixtures'
|
|
const OPTIONS = { scenario: 'manual-order-inbound-status-matrix', deploymentBlocker: true }
|
|
const MERCHANT_USERNAME = process.env.MERCHANT_TEST_USERNAME || ''
|
|
const MERCHANT_PASSWORD = process.env.MERCHANT_TEST_PASSWORD || ''
|
|
|
|
const ORDER_TARGETS = [
|
|
['DRAFT', []],
|
|
['SUBMITTED', ['submit']],
|
|
['REJECTED', ['submit', 'reject']],
|
|
['APPROVED', ['submit', 'approve']],
|
|
['ACCEPTED', ['submit', 'approve', 'accept']],
|
|
['PROCESSING', ['submit', 'approve', 'accept', 'start']],
|
|
['COMPLETED', []],
|
|
['CANCELLED', ['cancel']],
|
|
]
|
|
const INBOUND_FILTER_STATUSES = [
|
|
'WAIT_MEASURE', 'MEASURING', 'MEASURE_PENDING', 'MEASURE_REJECTED', 'WAIT_PRICING',
|
|
'FEE_CONFIRMING', 'INBOUNDING', 'WAIT_SPLIT', 'VOIDED',
|
|
]
|
|
const UNIFIED_FILTER_STATUSES = [
|
|
'PENDING_REVIEW', 'WAIT_MEASURE', 'WAIT_SPLIT', 'LOADING', 'LOADED', 'DELIVERED',
|
|
]
|
|
|
|
function id(value) { return value == null ? '' : String(value) }
|
|
function rows(value) { return Array.isArray(value?.records) ? value.records : [] }
|
|
function ok(response) { return response?.http === 200 && String(response?.body?.code) === '200' }
|
|
function data(response) { return response?.body?.data }
|
|
function key(context, operation) { return `${context.marker}-manual-${operation}`.slice(0, 128) }
|
|
function query(value) { return encodeURIComponent(String(value)) }
|
|
function wait(milliseconds) { return new Promise((resolve) => setTimeout(resolve, milliseconds)) }
|
|
|
|
async function merchantRequest(context, method, path, body, token, headers = {}) {
|
|
const requestHeaders = { Accept: 'application/json', Authorization: `Bearer ${token}`, ...headers }
|
|
const payload = body === undefined ? undefined : JSON.stringify(body)
|
|
if (payload !== undefined) requestHeaders['Content-Type'] = 'application/json; charset=utf-8'
|
|
try {
|
|
const response = await fetch(`${context.options.gateway}${path}`, {
|
|
method, headers: requestHeaders, body: payload, signal: AbortSignal.timeout(30_000),
|
|
})
|
|
const content = await response.text()
|
|
let parsed = null
|
|
try { parsed = content ? JSON.parse(content) : null } catch { /* Keep bounded raw evidence. */ }
|
|
return { method, path, http: response.status, body: parsed, raw: parsed ? null : content.slice(0, 500),
|
|
requestId: parsed?.requestId || response.headers.get('x-request-id'),
|
|
traceId: parsed?.traceId || response.headers.get('x-trace-id') }
|
|
} catch (error) {
|
|
return { method, path, http: 0, body: null, raw: String(error), requestId: null, traceId: null }
|
|
}
|
|
}
|
|
|
|
async function merchantGet(context, path, token) {
|
|
return merchantRequest(context, 'GET', path, undefined, token)
|
|
}
|
|
|
|
async function loadFixtureInputs(context, token) {
|
|
const profileResponse = await merchantGet(context, '/api/merchant/v1/iam/tenant/profile', token)
|
|
const profile = context.apiSuccess(MODULE, '读取 IT 测试客户资料', profileResponse)
|
|
const domesticResponse = await merchantGet(context,
|
|
'/api/merchant/v1/warehouses?page=1&size=200&status=ACTIVE&warehouseType=DOMESTIC', token)
|
|
const domesticPage = context.apiSuccess(MODULE, '读取国内收货仓', domesticResponse)
|
|
const receivings = rows(domesticPage).filter((item) => item?.status === 'ACTIVE')
|
|
const destinationResponse = await merchantGet(context,
|
|
'/api/merchant/v1/warehouses?page=1&size=200&status=ACTIVE&warehouseType=FBA', token)
|
|
const destinations = rows(context.apiSuccess(MODULE, '读取 FBA 目的仓', destinationResponse))
|
|
if (!profile?.id || receivings.length === 0 || destinations.length === 0) throw new Error('状态样本缺少客户或仓库基础数据')
|
|
const priced = await findPricedOrderRouteAcrossOrigins({
|
|
receivings, destinations,
|
|
loadChannels: (receiving) => merchantGet(context,
|
|
`/api/merchant/v1/first-leg/pricing/channels?originWarehouseId=${query(receiving.id)}`, token),
|
|
estimate: (body) => merchantRequest(context, 'POST', '/api/merchant/v1/first-leg/pricing/estimate', body, token),
|
|
})
|
|
if (!priced.receiving || !priced.priced) throw new Error('状态样本缺少真实可计价的仓库/渠道/目的仓组合')
|
|
return { tenantId: id(profile.id), customerName: profile.tenantName || 'IT 测试客户',
|
|
domestic: priced.receiving, destination: priced.priced.destination, channel: priced.priced.channel,
|
|
pricingTaxMode: priced.priced.pricingTaxMode }
|
|
}
|
|
|
|
function orderPayload(context, fixture, target) {
|
|
const sample = `${context.marker}-${target}`
|
|
const shipmentId = `MANUAL-${target}-${context.marker}`.slice(0, 64)
|
|
const referenceId = `STATUS-${target}-${context.marker}`.slice(0, 64)
|
|
const upcNo = `${String(context.marker).replace(/\D/g, '').slice(-11)}${ORDER_TARGETS.findIndex(([status]) => status === target) + 1}`
|
|
.slice(-12).padStart(12, '0')
|
|
return {
|
|
customerId: null, customerName: fixture.customerName, transportMode: 'SEA', tradeTerm: 'FOB',
|
|
destinationCountryCode: fixture.destination.countryCode || 'US',
|
|
destinationWarehouseId: fixture.destination.id, destinationWarehouseName: fixture.destination.warehouseName,
|
|
expectedShipDate: new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 10),
|
|
customerRemark: `${sample} 人工列表状态样本`, pickupMethod: 'SELF_EXPRESS',
|
|
receivingWarehouseId: fixture.domestic.id, receivingWarehouseName: fixture.domestic.warehouseName,
|
|
channelCode: fixture.channel.channelCode, channelName: fixture.channel.channelName,
|
|
carrierId: null, carrierName: null, taxMode: 'BUY_DECLARATION',
|
|
pricingTaxMode: fixture.pricingTaxMode, containerMode: 'LCL', customsInspection: false,
|
|
destinationType: 'FBA', amazonWarehouseCode: fixture.destination.warehouseCode,
|
|
shipmentId, referenceId,
|
|
sender: { companyName: fixture.customerName, contactName: 'IT 测试联系人', phone: '13800138000',
|
|
email: 'it-test@example.com', countryCode: 'CN', province: '广东省', city: '深圳市', district: '南山区',
|
|
addressLine: `${sample} 测试地址`, postalCode: '518000' },
|
|
receiver: null,
|
|
cargoes: [{ cargoName: `${target} 状态样本货物`, cargoNameEn: `${target} fixture cargo`, hsCode: '8518210000',
|
|
customsHsCode: '8518210000', packageType: 'CARTON', packageCount: 1, grossWeightKg: 10,
|
|
volumeCbm: 0.024, lengthCm: 40, widthCm: 30, heightCm: 20, declaredValue: 100, currency: 'USD',
|
|
dangerousGoods: false, woodenProduct: false, cargoRemark: sample, skuNo: `SKU-${target}-${context.marker}`.slice(0, 64),
|
|
upcNo, shipmentId, referenceId,
|
|
unitsPerPackage: 10, totalQuantity: 10, netWeightKg: 9, unitDeclaredValue: 10,
|
|
material: '塑料', usage: '人工验收', model: `MODEL-${target}`, brand: 'IT-TEST' }],
|
|
}
|
|
}
|
|
|
|
async function createOrder(context, token, fixture, target) {
|
|
const response = await merchantRequest(context, 'POST', '/api/merchant/v1/orders/first-leg',
|
|
orderPayload(context, fixture, target), token, { 'Idempotency-Key': key(context, `${target}-create`) })
|
|
const orderId = id(context.apiSuccess(MODULE, `创建 ${target} 订单状态样本`, response))
|
|
if (!orderId) throw new Error(`${target} 状态样本未返回订单 ID`)
|
|
return orderId
|
|
}
|
|
|
|
export async function transition(context, token, fixture, orderId, target, action) {
|
|
const merchantPath = `/api/merchant/v1/orders/first-leg/${query(orderId)}`
|
|
if (action === 'submit') {
|
|
const detail = context.apiSuccess(MODULE, `${target} 冻结提交版本`, await merchantRequest(context, 'GET', merchantPath, undefined, token))
|
|
const command = freezeOrderCommand(detail, key(context, `${target}-submit`))
|
|
const response = await merchantRequest(context, 'POST', `${merchantPath}/submit`, command.body, token, command.headers)
|
|
context.apiSuccess(MODULE, `${target} 样本提交订单`, response)
|
|
return
|
|
}
|
|
const platformPath = `/api/platform/v1/orders/first-leg/${query(orderId)}/${action}?tenantId=${query(fixture.tenantId)}`
|
|
const body = action === 'reject' || action === 'cancel' ? { reason: `${context.marker} 保留 ${target} 人工样本` } : undefined
|
|
const command = action === 'cancel' ? freezeOrderCommand(context.apiSuccess(MODULE, `${target} 冻结取消版本`,
|
|
await context.request('GET', `/api/platform/v1/orders/first-leg/${query(orderId)}?tenantId=${query(fixture.tenantId)}`)),
|
|
key(context, `${target}-cancel`), body) : null
|
|
const response = await context.request('POST', platformPath, command?.body ?? body, context.token, command?.headers ?? {})
|
|
context.apiSuccess(MODULE, `${target} 样本执行 ${action}`, response)
|
|
}
|
|
|
|
export async function createCompletedOrder(context, runFulfillment = async scope => {
|
|
const { run } = await import('./phase5-root-fulfillment.mjs')
|
|
return run(scope)
|
|
}, prepareCustomer = async scope => {
|
|
const { run } = await import('./merchant-qualification-fixture.mjs')
|
|
return run(scope, { publishEnvironment: false, requireDistinctCustomer: false })
|
|
}) {
|
|
const scope = Object.create(context)
|
|
scope.marker = `${context.marker}-COMPLETED`
|
|
scope.context = { ...context.context, f40SignatureOrder: 'ROOT_FIRST' }
|
|
scope.createdResources = { ...context.createdResources }
|
|
await prepareCustomer(scope)
|
|
try { await runFulfillment(scope) }
|
|
finally { context.createdResources.manualCompletedOrder = scope.createdResources.phase5RootFulfillment }
|
|
const proof = scope.createdResources.phase5RootFulfillment
|
|
if (proof?.finalStatus !== 'VERIFIED'
|
|
|| id(proof.customerId) !== id(scope.context.merchantQualificationFixture?.tenantId)
|
|
|| !id(proof.rootOrderId)) throw new Error('COMPLETED 样本必须由同客户真实签收及完成Outbox验证产生')
|
|
return { orderId: id(proof.rootOrderId), tenantId: id(proof.customerId) }
|
|
}
|
|
|
|
async function readOrder(context, fixture, orderId) {
|
|
const response = await context.request('GET',
|
|
`/api/platform/v1/orders/first-leg/${query(orderId)}?tenantId=${query(fixture.tenantId)}`)
|
|
return { response, detail: context.apiSuccess(MODULE, '回读订单状态样本', response) }
|
|
}
|
|
|
|
async function waitForInbound(context, fixture, orderId, allowCompletedOrder = false) {
|
|
const path = `/api/platform/v1/orders/${query(orderId)}?tenantId=${query(fixture.tenantId)}`
|
|
// 审核/接受/完成会经过跨服务履约事件；测试环境高负载时可能超过10秒才落入库单。
|
|
// 保持轮询只读并延长观察窗口，避免把异步延迟误判为“未生成入库单”。
|
|
for (let attempt = 0; attempt < 240; attempt += 1) {
|
|
const response = await context.request('GET', path)
|
|
const summary = data(response)?.summary
|
|
if (ok(response) && summary?.inboundId
|
|
&& (allowCompletedOrder || ['WAIT_MEASURE', 'MEASURING', 'MEASURE_PENDING', 'MEASURE_REJECTED', 'WAIT_SPLIT'].includes(summary.mainStatus))) {
|
|
return { response, summary }
|
|
}
|
|
if (attempt < 239) await wait(500)
|
|
}
|
|
return { response: null, summary: null }
|
|
}
|
|
|
|
export async function retainFeeConfirmingFixture(context, { inboundId, tenantId }) {
|
|
const suffix = `${query(inboundId)}?tenantId=${query(tenantId)}`
|
|
const detailPath = `/api/platform/inbounds/${suffix}`
|
|
const beforeResponse = await context.request('GET', detailPath)
|
|
const before = context.apiSuccess(MODULE, '试算前核对独立待审核测量样本', beforeResponse, '', OPTIONS)
|
|
if (id(before?.summary?.id) !== id(inboundId)
|
|
|| id(before?.summary?.tenantId) !== id(tenantId)
|
|
|| before?.summary?.processStatus !== 'MEASURE_PENDING' || !before?.summary?.inboundCode) {
|
|
throw new Error('FEE_CONFIRMING 必须从本轮独立 MEASURE_PENDING 入库单生成')
|
|
}
|
|
const calculatedResponse = await context.request('POST',
|
|
`/api/platform/v1/inbounds/${query(inboundId)}/fees/calculate?tenantId=${query(tenantId)}`,
|
|
{ weightSource: 'ACTUAL', volumeSource: 'ACTUAL' }, undefined,
|
|
{ 'Idempotency-Key': key(context, `retain-fee-confirming-${inboundId}`) })
|
|
const calculated = context.apiSuccess(MODULE, '审核前真实试算并保留待费用确认样本', calculatedResponse, '', OPTIONS)
|
|
if (!calculated?.feeId || calculated?.feeStatus !== 'CALCULATED'
|
|
|| calculated?.nextProcessStatus !== 'FEE_CONFIRMING') {
|
|
throw new Error('真实费用试算未生成 FEE_CONFIRMING/CALCULATED')
|
|
}
|
|
const latestResponse = await context.request('GET',
|
|
`/api/platform/v1/inbounds/${query(inboundId)}/fees/latest?tenantId=${query(tenantId)}`)
|
|
const latest = context.apiSuccess(MODULE, '回读待确认费用的同一快照', latestResponse, '', OPTIONS)
|
|
const detailResponse = await context.request('GET', detailPath)
|
|
const detail = context.apiSuccess(MODULE, '回读待费用确认样本持久状态', detailResponse, '', OPTIONS)
|
|
const valid = id(detail?.summary?.id) === id(inboundId)
|
|
&& id(detail?.summary?.tenantId) === id(tenantId)
|
|
&& detail?.summary?.processStatus === 'FEE_CONFIRMING'
|
|
&& detail?.summary?.measureReviewStatus === 'PENDING'
|
|
&& id(latest?.feeId) === id(calculated.feeId)
|
|
&& latest?.feeVersion === calculated.feeVersion && latest?.feeStatus === 'CALCULATED'
|
|
context.assert(MODULE, '费用已持久化且测量尚未审核，保留 FEE_CONFIRMING', detailResponse, valid,
|
|
`status=${detail?.summary?.processStatus || 'missing'}, feeId=${id(latest?.feeId)}`, OPTIONS)
|
|
if (!valid) throw new Error('FEE_CONFIRMING 持久状态或费用快照不一致')
|
|
const listResponse = await context.request('GET',
|
|
`/api/platform/inbounds?tenantId=${query(tenantId)}&inboundCode=${query(before.summary.inboundCode)}&processStatus=FEE_CONFIRMING&page=1&size=20`)
|
|
const page = context.apiSuccess(MODULE, '按 FEE_CONFIRMING 查询保留样本', listResponse, '', OPTIONS)
|
|
const visible = rows(page).some(row => id(row.id) === id(inboundId) && row.processStatus === 'FEE_CONFIRMING')
|
|
context.assert(MODULE, '待费用确认筛选包含本轮真实样本', listResponse, visible,
|
|
`inboundId=${inboundId}`, OPTIONS)
|
|
if (!visible) throw new Error('FEE_CONFIRMING 列表未包含本轮样本')
|
|
return { feeId: id(latest.feeId), feeVersion: latest.feeVersion }
|
|
}
|
|
|
|
export async function retainWaitPricingFixture(context, { inboundId, tenantId, orderId }) {
|
|
const detailPath = `/api/platform/inbounds/${query(inboundId)}?tenantId=${query(tenantId)}`
|
|
const before = context.apiSuccess(MODULE, '渠道变更前核对独立费用确认样本',
|
|
await context.request('GET', detailPath), '', OPTIONS)
|
|
const orderDetail = context.apiSuccess(MODULE, '渠道变更前读取当前订单版本与申报',
|
|
await context.request('GET', `/api/platform/v1/orders/first-leg/${query(orderId)}?tenantId=${query(tenantId)}`), '', OPTIONS)
|
|
const order = orderDetail?.order
|
|
if (id(before?.summary?.id) !== id(inboundId) || id(before?.summary?.tenantId) !== id(tenantId)
|
|
|| id(before?.summary?.orderId) !== id(orderId) || before?.summary?.processStatus !== 'FEE_CONFIRMING'
|
|
|| id(order?.id) !== id(orderId) || order?.status !== 'APPROVED' || !orderDetail?.cargoes?.length) {
|
|
throw new Error('WAIT_PRICING 必须从本轮 APPROVED 订单及 FEE_CONFIRMING 入库单生成')
|
|
}
|
|
const fixture = context.context?.merchantQualificationFixture
|
|
const username = fixture?.username || context.options?.merchantUsername || process.env.MERCHANT_TEST_USERNAME
|
|
const password = fixture?.password || context.options?.merchantPassword || process.env.MERCHANT_TEST_PASSWORD
|
|
const login = context.apiSuccess(MODULE, '渠道样本客户独立登录',
|
|
await context.request('POST', '/api/auth/login', { loginId: username, password }, ''), '', OPTIONS)
|
|
if (!login?.accessToken) throw new Error('WAIT_PRICING 客户登录缺少会话')
|
|
const token = login.accessToken
|
|
try {
|
|
const profile = context.apiSuccess(MODULE, '核对渠道目录所属客户',
|
|
await context.request('GET', '/api/merchant/v1/iam/tenant/profile', undefined, token), '', OPTIONS)
|
|
if (id(profile?.id) !== id(tenantId)) throw new Error('WAIT_PRICING 渠道目录客户身份不一致')
|
|
const channels = context.apiSuccess(MODULE, '查询同仓可替换报价渠道',
|
|
await context.request('GET', `/api/merchant/v1/first-leg/pricing/channels?originWarehouseId=${query(order.receivingWarehouseId)}`,
|
|
undefined, token), '', OPTIONS)
|
|
const route = await findPricedOrderRoute({
|
|
receiving: { id: order.receivingWarehouseId },
|
|
destinations: [{ id: order.destinationWarehouseId, warehouseCode: order.amazonWarehouseCode,
|
|
warehouseName: order.destinationWarehouseName }],
|
|
channels: (Array.isArray(channels) ? channels : []).filter(channel => channel.channelCode !== order.channelCode
|
|
&& channel.pricingTaxModes?.includes(order.pricingTaxMode))
|
|
.map(channel => ({ ...channel, pricingTaxModes: [order.pricingTaxMode] })),
|
|
destinationType: order.destinationType, concurrency: 1,
|
|
estimate: body => context.request('POST', '/api/merchant/v1/first-leg/pricing/estimate', body, token),
|
|
})
|
|
if (!route?.priced?.channel) throw new Error('WAIT_PRICING 没有同仓同目的仓同税制的实际可计价替换渠道')
|
|
const channel = route.priced.channel
|
|
const changedResponse = await context.request('PUT',
|
|
`/api/platform/v1/orders/${query(orderId)}/declaration?tenantId=${query(tenantId)}`,
|
|
{ expectedVersion: Number(order.version), customerRemark: order.customerRemark,
|
|
expectedArrivalAt: order.expectedArrivalAt || null, estimatedVolumeCbm: order.estimatedVolumeCbm ?? null,
|
|
channelCode: channel.channelCode, channelName: channel.channelName,
|
|
cargoes: orderDetail.cargoes.map(cargo => Object.fromEntries([
|
|
'itemNo', 'cargoName', 'cargoNameEn', 'skuNo', 'model', 'packageCount', 'totalQuantity',
|
|
'lengthCm', 'widthCm', 'heightCm', 'grossWeightKg', 'volumeCbm', 'netWeightKg',
|
|
'hsCode', 'customsHsCode', 'unitsPerPackage', 'unitDeclaredValue', 'declaredValue',
|
|
'currency', 'material', 'usage', 'brand', 'cargoRemark',
|
|
].map(field => [field, cargo[field] ?? (field === 'cargoRemark' ? cargo.remark : null) ?? null]))) })
|
|
const changed = context.apiSuccess(MODULE, '通过正式申报接口变更本轮未发布费用订单渠道', changedResponse, '', OPTIONS)
|
|
if (Number(changed?.version) !== Number(order.version) + 1 || changed?.channelChanged !== true) {
|
|
throw new Error('WAIT_PRICING 渠道变更未确认当前订单版本')
|
|
}
|
|
let detail
|
|
let response
|
|
for (let attempt = 0; attempt < 30; attempt += 1) {
|
|
response = await context.request('GET', detailPath)
|
|
detail = context.apiSuccess(MODULE, '等待渠道变更及费用失效事实收敛', response, '', OPTIONS)
|
|
if (detail?.summary?.processStatus === 'WAIT_PRICING'
|
|
&& detail?.summary?.channelCode === channel.channelCode) break
|
|
if (attempt < 29) await wait(500)
|
|
}
|
|
const valid = id(detail?.summary?.id) === id(inboundId) && id(detail?.summary?.tenantId) === id(tenantId)
|
|
&& detail?.summary?.processStatus === 'WAIT_PRICING' && detail?.summary?.feeStatus === 'UNPRICED'
|
|
&& detail?.summary?.channelCode === channel.channelCode
|
|
context.assert(MODULE, '真实渠道变更保留 WAIT_PRICING 且旧费用失效', response, valid,
|
|
`status=${detail?.summary?.processStatus}, feeStatus=${detail?.summary?.feeStatus}`, OPTIONS)
|
|
if (!valid) throw new Error('WAIT_PRICING 渠道变更事实未收敛')
|
|
const listResponse = await context.request('GET',
|
|
`/api/platform/inbounds?tenantId=${query(tenantId)}&inboundCode=${query(before.summary.inboundCode)}&processStatus=WAIT_PRICING&page=1&size=20`)
|
|
const page = context.apiSuccess(MODULE, '按 WAIT_PRICING 筛选本轮样本', listResponse, '', OPTIONS)
|
|
const visible = rows(page).some(row => id(row.id) === id(inboundId) && row.processStatus === 'WAIT_PRICING')
|
|
context.assert(MODULE, '待计费筛选包含本轮真实样本', listResponse, visible, `inboundId=${inboundId}`, OPTIONS)
|
|
if (!visible) throw new Error('WAIT_PRICING 列表未包含本轮样本')
|
|
} finally {
|
|
context.apiSuccess(MODULE, '退出渠道目录客户独立会话',
|
|
await context.request('POST', '/api/auth/logout', { refreshToken: login.refreshToken }, token), '', OPTIONS)
|
|
}
|
|
}
|
|
|
|
async function prepareInboundStatus(context, target) {
|
|
const originalMarker = context.marker
|
|
const originalRequest = context.request
|
|
const fixtureMarker = `${originalMarker}-IN-${target}`
|
|
const stop = Symbol(target)
|
|
const createdKeys = ['orders', 'ocrInbound', 'testInbound', 'inboundMeasurement', 'inboundWarehouseResources']
|
|
const contextKeys = ['inboundWeightOcr', 'ocrInbound', 'testInbound', 'createdInbound', 'orderStopAtApproved']
|
|
const createdSnapshot = new Map(createdKeys.map((name) => [name,
|
|
{ present: Object.hasOwn(context.createdResources, name), value: context.createdResources[name] }]))
|
|
const contextSnapshot = new Map(contextKeys.map((name) => [name,
|
|
{ present: Object.hasOwn(context.context, name), value: context.context[name] }]))
|
|
try {
|
|
context.marker = fixtureMarker
|
|
if (target === 'WAIT_PRICING') context.context.orderStopAtApproved = true
|
|
const orders = await import(new URL('./orders.mjs', import.meta.url))
|
|
await orders.run(context)
|
|
const order = { ...context.createdResources.orders }
|
|
const inboundId = id(order.inboundId)
|
|
const tenantId = id(order.tenantId)
|
|
if (!inboundId || !tenantId) throw new Error(`${target} 未生成独立待测量入库单`)
|
|
const detailPath = `/api/platform/inbounds/${query(inboundId)}?tenantId=${query(tenantId)}`
|
|
|
|
if (target === 'MEASURING') {
|
|
const weightOcr = await import(new URL('./inbound-weight-ocr.mjs', import.meta.url))
|
|
await weightOcr.run(context)
|
|
}
|
|
|
|
context.request = async (method, path, body, token, headers) => {
|
|
const isSubmit = path.includes(`/inbounds/${inboundId}/measurement/submit`)
|
|
if (['MEASURE_PENDING', 'FEE_CONFIRMING', 'WAIT_PRICING'].includes(target) && isSubmit) {
|
|
const response = await originalRequest.call(context, method, path, body, token, headers)
|
|
if (!ok(response)) throw new Error(`MEASURE_PENDING 提交失败: HTTP=${response?.http}, code=${response?.body?.code}`)
|
|
throw stop
|
|
}
|
|
return originalRequest.call(context, method, path, body, token, headers)
|
|
}
|
|
if (target !== 'MEASURING') {
|
|
try {
|
|
const measurement = await import(new URL('./inbound-measurement.mjs', import.meta.url))
|
|
await measurement.run(context)
|
|
} catch (error) {
|
|
if (error !== stop) throw error
|
|
} finally {
|
|
context.request = originalRequest
|
|
}
|
|
}
|
|
|
|
if (['FEE_CONFIRMING', 'WAIT_PRICING'].includes(target)) {
|
|
await retainFeeConfirmingFixture(context, { inboundId, tenantId })
|
|
}
|
|
if (target === 'WAIT_PRICING') {
|
|
await retainWaitPricingFixture(context, { inboundId, tenantId, orderId: id(order.orderId) })
|
|
}
|
|
|
|
let response = null
|
|
let detail = null
|
|
for (let attempt = 1; attempt <= 8; attempt += 1) {
|
|
response = await originalRequest.call(context, 'GET',
|
|
`/api/platform/inbounds/${query(inboundId)}?tenantId=${query(tenantId)}`)
|
|
detail = response?.http === 200 && String(response?.body?.code) === '200' ? response.body.data : null
|
|
if (detail?.summary?.processStatus === target || attempt === 8) break
|
|
await new Promise((resolve) => setTimeout(resolve, 500 * attempt))
|
|
}
|
|
detail = context.apiSuccess(MODULE, `回读 ${target} 独立入库单`, response, '', OPTIONS)
|
|
context.assert(MODULE, `${target} 入库状态样本可从详情打开`, response,
|
|
detail?.summary?.processStatus === target, `inboundId=${inboundId}, actual=${detail?.summary?.processStatus || 'missing'}`, OPTIONS)
|
|
return { inboundId, orderId: id(order.orderId), tenantId, status: target,
|
|
inboundCode: detail?.summary?.inboundCode || null }
|
|
} finally {
|
|
context.request = originalRequest
|
|
context.marker = originalMarker
|
|
for (const [name, snapshot] of createdSnapshot) {
|
|
if (snapshot.present) context.createdResources[name] = snapshot.value
|
|
else Reflect.deleteProperty(context.createdResources, name)
|
|
}
|
|
for (const [name, snapshot] of contextSnapshot) {
|
|
if (snapshot.present) context.context[name] = snapshot.value
|
|
else Reflect.deleteProperty(context.context, name)
|
|
}
|
|
}
|
|
}
|
|
|
|
export async function run(context, matrix = context.createdResources.manualStateMatrix) {
|
|
if (!matrix) {
|
|
matrix = { marker: context.marker, generatedAt: new Date().toISOString(), pages: {} }
|
|
context.createdResources.manualStateMatrix = matrix
|
|
}
|
|
matrix.pages ||= {}
|
|
const loginResponse = await context.request('POST', '/api/auth/login',
|
|
{ loginId: MERCHANT_USERNAME, password: MERCHANT_PASSWORD }, '')
|
|
const token = context.apiSuccess(MODULE, 'IT 测试客户管理员登录', loginResponse)?.accessToken
|
|
if (!token) throw new Error('客户管理员登录未返回 accessToken')
|
|
const fixture = await loadFixtureInputs(context, token)
|
|
const result = { marker: context.marker, tenantId: fixture.tenantId, orders: {}, inbounds: {}, unifiedOrders: {} }
|
|
matrix.pages.firstLegOrders = { requiredStatuses: ORDER_TARGETS.map(([status]) => status), fixtures: {} }
|
|
matrix.pages.inbounds = { requiredStatuses: INBOUND_FILTER_STATUSES, fixtures: {} }
|
|
matrix.pages.unifiedOrders = { requiredStatuses: UNIFIED_FILTER_STATUSES, fixtures: {} }
|
|
|
|
for (const [target, actions] of ORDER_TARGETS) {
|
|
const completed = target === 'COMPLETED' ? await createCompletedOrder(context) : null
|
|
const activeFixture = completed ? { ...fixture, tenantId: completed.tenantId } : fixture
|
|
const orderId = completed?.orderId || await createOrder(context, token, activeFixture, target)
|
|
for (const action of actions) await transition(context, token, activeFixture, orderId, target, action)
|
|
const { response, detail } = await readOrder(context, activeFixture, orderId)
|
|
context.assert(MODULE, `${target} 订单状态样本可从详情打开`, response,
|
|
id(detail?.order?.id) === orderId && detail?.order?.status === target,
|
|
`orderId=${orderId}, status=${detail?.order?.status ?? 'missing'}`)
|
|
result.orders[target] = { orderId, tenantId: activeFixture.tenantId, orderNo: detail?.order?.orderNo || null, status: target,
|
|
listPath: `/admin/first-leg-orders?status=${target}` }
|
|
matrix.pages.firstLegOrders.fixtures[target] = {
|
|
id: orderId, tenantId: activeFixture.tenantId, status: target, detailPath: `/orders/${orderId}`,
|
|
}
|
|
|
|
if (actions.includes('approve')) {
|
|
const inbound = await waitForInbound(context, fixture, orderId, target === 'COMPLETED')
|
|
const inboundId = id(inbound.summary?.inboundId)
|
|
context.assert(MODULE, `${target} 订单生成待测量入库单`, inbound.response, Boolean(inboundId),
|
|
`orderId=${orderId}, inboundId=${inboundId || 'missing'}`)
|
|
if (inboundId && !result.inbounds.WAIT_MEASURE) result.inbounds.WAIT_MEASURE = {
|
|
inboundId, inboundCode: inbound.summary?.inboundCode || null, orderId, processStatus: 'WAIT_MEASURE',
|
|
listPath: '/admin/inbounds?processStatus=WAIT_MEASURE',
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const [status, sample] of Object.entries(result.orders)) {
|
|
const response = await context.request('GET',
|
|
`/api/platform/v1/orders/first-leg?tenantId=${query(sample.tenantId)}&status=${status}&keyword=${query(sample.orderNo)}&page=1&size=20`)
|
|
const page = context.apiSuccess(MODULE, `${status} 订单可按列表状态筛选`, response)
|
|
context.assert(MODULE, `${status} 筛选结果包含人工样本`, response,
|
|
rows(page).some((item) => id(item.id) === sample.orderId), `orderId=${sample.orderId}, total=${page?.total ?? 'n/a'}`)
|
|
}
|
|
|
|
const waitMeasure = result.inbounds.WAIT_MEASURE
|
|
if (waitMeasure) matrix.pages.inbounds.fixtures.WAIT_MEASURE = {
|
|
id: waitMeasure.inboundId, status: 'WAIT_MEASURE', detailPath: `/orders/${waitMeasure.orderId}`,
|
|
}
|
|
|
|
const submitted = result.orders.SUBMITTED
|
|
result.unifiedOrders.PENDING_REVIEW = { orderId: submitted.orderId, orderNo: submitted.orderNo,
|
|
mainStatus: 'PENDING_REVIEW', listPath: '/admin/unified-orders?mainStatus=PENDING_REVIEW' }
|
|
matrix.pages.unifiedOrders.fixtures.PENDING_REVIEW = {
|
|
id: submitted.orderId, status: 'PENDING_REVIEW', detailPath: `/orders/${submitted.orderId}`,
|
|
}
|
|
if (waitMeasure) result.unifiedOrders.WAIT_MEASURE = { orderId: waitMeasure.orderId,
|
|
inboundId: waitMeasure.inboundId, mainStatus: 'WAIT_MEASURE', listPath: '/admin/unified-orders?mainStatus=WAIT_MEASURE' }
|
|
if (waitMeasure) matrix.pages.unifiedOrders.fixtures.WAIT_MEASURE = {
|
|
id: waitMeasure.orderId, status: 'WAIT_MEASURE', detailPath: `/orders/${waitMeasure.orderId}`,
|
|
}
|
|
|
|
for (const status of ['MEASURING', 'MEASURE_PENDING', 'FEE_CONFIRMING', 'WAIT_PRICING', 'WAIT_SPLIT']) {
|
|
const sample = await prepareInboundStatus(context, status)
|
|
result.inbounds[status] = sample
|
|
matrix.pages.inbounds.fixtures[status] = {
|
|
id: sample.inboundId, status, detailPath: `/orders/${sample.orderId}`,
|
|
}
|
|
if (status === 'WAIT_SPLIT') {
|
|
result.unifiedOrders.WAIT_SPLIT = sample
|
|
matrix.pages.unifiedOrders.fixtures.WAIT_SPLIT = {
|
|
id: sample.orderId, status, detailPath: `/orders/${sample.orderId}`,
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!result.inbounds.WAIT_SPLIT) {
|
|
throw new Error('本轮 WAIT_SPLIT 独立样本缺失，不允许借用历史数据')
|
|
}
|
|
|
|
context.addStep(MODULE, '登记订单/入库人工状态矩阵', null, true,
|
|
`orders=${Object.keys(result.orders).length}, inbounds=${Object.keys(result.inbounds).length}`, OPTIONS)
|
|
}
|